Early Detection of Distributed Denial of Service in Cloud Computing Using Quantum-Enhanced Knowledge Distillation Framework

Abstract

Cloud computing is one of the essential computing platforms for modern enterprises. About 98 percent of large businesses will use cloud computing services in 2025 to enable remote working. The highly distributed structures of cloud computing are prone to attacks starting from weakened access control to data breaches. The sources making cloud systems vulnerable to attacks are public accessibility, auto scaling, and shared form of network architecture. Distributed Denial of Service (DDoS) is one of the most serious forms of attacks where multiple botnets get created simultaneously and flood massive requests for the cloud services. If the DDoS attack is not identified early it leads to the unavailability of cloud services, increased cost of migration, exhaustion of resources, and frequent violations of Service Level Agreements (SLAs). Hence, there is a need to detect DDoS at an early stage. Traditional machine learning models demand high computational power and larger memory capacity which make it unsuitable for a real-time cloud environment. This limitation is overcome by presenting a novel Quantum-Enhanced Knowledge Distillation framework (QKD) to detect DDoS attacks in cloud systems. QKD is a highly potential form of architecture which uses quantum computing to enhance the knowledge transfer between teacher and student models. The knowledge is extracted from the teacher model and quantum encoding of knowledge is performed. The complex correlation between the features of the traffic is extracted by applying the entanglement gates. The student model is trained considering the distillation loss and optimized until convergence. The simulation of the QKD is performed using DynamicCloudSim 3.0.3 simulator considering benchmark dataset CIC-DDoS2019and the performance is further validated using expected value analysis methodology. The performance of QKD is found to be promising toward performance metrics such as packet loss rate, attack detection time, attack recovery ratio, bandwidth utilization, and response time.

1. Introduction

Cloud computing is one of the popular computing platforms adopted by 98% of enterprises because of its flexibility, scalability, and reduced cost of operation. The platform is enhanced through Artificial Intelligence/Machine Learning integration to provide remote working capability and rapid form of digital transformation with improved data security. The market value of all forms of cloud, i.e., private cloud, public cloud, and hybrid cloud is expected to reach USD 1.6 trillion by the year 2030 [1,2]. The cloud market is predominantly dominated by hyperscalers such as Amazon Web Services, Microsoft Azure, and Google Cloud. The key drivers for the success of cloud computing are the integration of Artificial Intelligence (AI), extending support for Business operation in remote work models, and serverless computation. Resource-intensive AI models which demand Graphical Processing Unit (GPU) clusters for scalable computing power are supported readily by cloud service providers. After the pandemic situation, many organizations have reached for accelerated adaptation of Microsoft 365 and Google workspace as tools of Software as a Service (SaaS) on permanent basis. It offers accelerated operational agility by spinning up/down the resources allowing for faster innovation and reducing the time taken to deliver the product on to the market [3,4].

Despite the popularity, cloud systems have inherent vulnerabilities and security weakness due to distributed architecture, insecure APIs, and insider threats. Cloud storage buckets are often subjected to misconfigurations and weak passwords which cause accidental data deletion and poor access control mechanism. Cloud databases are publicly exposed, which causes unauthorized access, data breaches, and poor key management. All cloud services are managed through APIs; weak authentication and insecure APIs allow for stealing the data and launch attacks to modify the configurations. Cloud access is provided through the internet, due to which fast data exfiltration will happen. The insider threats may arise from malicious insiders, negligent insiders, and compromised insiders. Malicious insiders will intentionally steal confidential information and delete the resources. Negligent insiders share the credentials and expose the database. Similarly, compromised insiders hack the legitimate accounts and steal employee credentials. The data in storage buckets and virtual machine disks are not encrypted during rest time which causes serious business risks and data breaches where access of sensitive data is gained by the attackers. Overloaded hypervisors cause virtual machines to crash through Denial of Service (DoS) attacks, in which the attackers do not provide resources for legitimate clients [5,6].

Out of all forms of attacks, a Distributed Denial of Service (DDoS) attack is the most powerful attack as it is the most frequent and more disruptive in nature. DDoS is one of the cyber attacks in which multiple devices send a huge amount of request traffic to servers so that its speed of operation decreases and gradually become unavailable for legitimate users. The cloud services running on platforms like Amazon, Microsoft Azure, and Google cloud are also targeted through DDoS attack. The attacker basically infects many devices, and these devices form a botnet. The servers will be utilized 100%, and there will be no processing power left to process the upcoming requests. As memory consumption increases, there will be chances of virtual machines getting overloaded which leads to performance instability. Due to extremely high traffic, the bandwidth congestion happens and reaches bandwidth saturation stage. Unnecessary auto scaling of resources happens to meet the increasing demands which leads to higher operational costs. Due to excessive log writing the database access gets overloaded with each of the disks reaches maximum Input/Output Operations Per Second (IOPS) causing I/O bottlenecks. Hence, there is a need to detect DDoS attack as early as possible to prevent resource exhaustion, unnecessary autoscaling of resources, and virtual machine downtime [7,8].

The Knowledge Distillation (KD) framework is one of the potential useful forms of machine learning approach in detection of DDoS attacks [9,10]. The main goal of the KD framework is to develop a lightweight model which can achieve higher performance with ease of operation. The teacher provides soft labels instead of hard labels as probability distribution which captures more informative information between the classes. However, training of the large teacher model and transferring the knowledge from teacher model to student model consume higher computational cost and exhibit longer time for training. Even when the knowledge is getting transferred from the teacher model to the student model, it might get lost during compression operation. The training of teacher models using large complex datasets often seems to be computationally expensive and slows down the overall execution of the model. The chances of getting stuck in a local minimum is higher due to the ineffective exploration of the state space environment. These challenges are handled effectively by the Quantum-Enhanced Knowledge Distillation (QKD) framework which guarantees better computational efficiency with enhanced feature selection and optimization capabilities [11,12].

Traditional machine learning approaches proposed in the literature to identify DDoS attacks suffer from serious limitations. Deep learning models are computationally expensive and demand more resources for training and deployment. The training time is usually large due to the involvement of many hidden layers. Deep learning models demand substantial amount of hardware resources and fail to capture generalized DDoS attack behavior. Communication overhead is more due to frequent exchange of parameters. Compared to traditional machine learning models, the QKD is computationally expensive in the initial stage of training the teacher model in offline mode. However, there will be significant reduction in the computation overhead during the deployment phase because of the lightweight nature of the student model. There is significant reduction in the number of parameters involved in the framework as it contains only fewer qubits, shallow form of variational circuits, quick packet classification, and lesser number of trainable parameters. The inference time taken to identify the DDoS attack is less as it performs only feature encoding, circuit operations, and measurement. Nonlinear relationships in the traffic pattern are represented through superposition, entanglement, and quantum state encoding which demand fewer computational resources. Energy consumption is reduced as the quantum student model requires lower processing cycles and a smaller number of memory access operations.

In this paper a novel QKD framework is proposed to perform early detection of DDoS attacks in cloud environment. DDoS attacks are identified early through pattern learning which yields higher accuracy outputs. The novelty of the QKD is larger machine learning model compressed using the Knowledge Distillation framework to achieve higher efficiency in operation. The huge traffic of the client requests is represented in a high dimensional quantum space using quantum feature mapping. The nonlinear patterns in the client requests are extracted using quantum teacher model which provides better generalization capability in DDoS attack detection. The student model gains more knowledge about DDoS attack patterns and captures the hidden relationship between classes to prevent overfitting problems. The larger teacher models are compressed into lightweight student models which makes the deployment easier and reduces the memory requirement.

The objectives of the paper are as follows:

• A brief introduction to increasing adaption rate of the cloud technology by the enterprises for large-scale operation;
• Identifying the vulnerabilities of the cloud technology which make it susceptible to various kinds of attacks;
• Explaining DDoS attacks, types of it and analyzing why is one of the major threats in cloud computing systems;
• Impact of DDoS attack on performance, cost of operation, and system availability;
• A brief introduction to KD framework consisting of the teacher model and the student model;
• Addressing the inherent limitation of the KD framework like loss of information (student loss and distillation loss) and training complexity using quantum states, and quantum feature mapping;
• Enhancing the capability of the KD framework using quantum theory to design a highly efficient machine learning model for early identification of the DDoS attacks;
• Design of the lightweight QKD architecture for early detection of DDoS attacks in cloud system through large scale data analysis;
• Expected value analysis of the QKD framework considering finite and infinite cloud computing scenarios towards the performance metrics;
• Experimental evaluation of the QKD framework using DynamicCloudSim 3.0.3 simulator which can simulate the dynamic and heterogenous nature of the cloud systems.

The remaining sections of the paper are organized as follows: Section 2 provides discussion over existing works. Section 3 gives the system model description and definitions for the performance metrics considered for evaluation. Section 4 gives the high-level architecture for DDoS attack detection using the QKD framework. Section 5 performs the expected value analysis of the QKD framework. Section 6 does experimental evaluation and discussion. Finally, Section 6 arrives at the conclusion and provides future enhancement that could be carried out in future.

2. Related Work

In this section, some of the potential recent papers on the detection of DD0S attacks in a cloud computing environment are discussed, and their limitations are highlighted.

Jyoti Tolanur et al. present a security model for detection of DDoS attacks using Federated Deep Learning (FDL) [13]. A set of decentralized nodes are considered and each of the nodes are trained, decentralized locally based on their local traffic. The main reason for training locally within the node is to preserve privacy and reduce the latency observed in a conventional centralized approach. A novel post quantum cryptography algorithm called crystals–kyber is proposed along with the conventional Advanced Encryption Standard (AES) algorithm to maintain confidentiality during data communication. The main foundation for the proposed approach is post-quantum security, lattice-based cryptography, and strong security notation using adaptively chosen ciphertext attack. It begins with the client registration phase in which the cloud server provides registration credentials (private key and device identity) to each of the authorized nodes. To perform symmetric encryption the server generates a pair of public/private key pairs. The client in turn generates shared secret key. The secret key is transmitted through client authentication process via a double encryption process. The double encryption is performed first by using client private key and server public key. The server reads the message by decrypting it using server private key and client public key. Once the channel becomes secure, the training of federated learning models is performed. The server first distributes the global parameters which are encrypted using shared secret key to all the client nodes. Each of the client node train using deep learning model considering its own private data to identify the traffic pattern which causes DDoS attacks. However, the computation cost involved in communication is higher because large-scale data transmission need to be carried out with limited key exchanges. The authentication is carried out using double encryption, which results in increased encryption cost and overhead in computation.

Hongxiang Ke et al. discussed a DDoS attack detection strategy using the Cuckoo Search-oriented Bidirectional Learning (CS-BL) algorithm [14]. Here, the conventional bidirectional form of Long Short-Term Memory (LSTM) network is improved using cuckoo search algorithm. The hidden unit’s parameters and time series length are adjusted dynamically to overcome the slower convergence and temporal interdependency problems. The cloud network resources are protected from malicious traffic. The critical threats posed by the DDoS attacks are identified, which is exhaustion of resources, i.e., memory, CPU, and bandwidth. Two categories of the DDoS attack are detected here: direct attacks and reflection attacks. Direct attacks drain the resources using TCP SYN flooding. Reflection attacks perform flooding of requests using intermediate computing units like routers and printers. The core components of cuckoo search algorithm are bidirectional learning network, and Levy flights search mechanism. The bidirectional learning network is a recurrent neural network which is basically designed to handle large scale datasets. It also solves vanishing gradient problems using gating units which are composed of forget gates, input gates, and output gates. It stores information for a longer period and can learn simultaneously from both past and future experience. The Levy flight performs random walks with heavy tail random distributions for global exploration of the state space and fine tuning of the solutions through local random walks. The DDoS attack detection works in three layers: the input layer, hidden layer, and output layer. The input layer arranges the input sequence of DDoS into several steps. The data (traffic volume, connection status) provided by the network sensors are collected and normalized for ensuring the consistency of the data across various attributes. The hidden layer uses LSTM units to directly learn from the data. The number of hidden units considered in the hidden layer act as a critical factor in the accuracy of the attack detection. The cuckoos search technique is used to determine an optimal number of hidden units and a combination of hidden units and time tie steps for reducing error in attack detection. The output layer uses fully connected network and sigmoid function to classify the DDoS as benign and malignant. However, the model struggles to adapt to unseen attack scenarios and suffers from poor generalization. Finding optimal parameters for heuristic optimization is difficult and often end up in more training loss and overfitting problems.

Maghrabi et al. present a mitigation strategy for DDoS attacks in large-scale computing framework using frilled lizard deep reinforcement learning [15]. A collaborative federated learning framework is designed to detect the DDoS attacks without loss of privacy. It begins with data normalization using Z-score normalization. The features of the input dataset are scaled to have mean value of zero and standard deviation of one. The main intention of data normalization is to prevent only one attribute dominating the machine learning process. The dimensionality reduction and computational efficiency is enhanced through bacterial foraging mechanism. The four phases of bacterial foraging, i.e., chemotaxis, swarming, reproduction, and elimination dispersal. The sine cosine algorithm is integrated with bacterial foraging algorithm which changes from fixed step size to adaptable step size. The classification of attacks is performed using double-deep Q network. The dual approach can differentiate between more significant actions and less significant actions. The overestimation bias is resolved by using separate target networks to determine the action values. Considering multiple federated learning agents, local models are trained using a dual network. Only encrypted gradients are used to ensure secure aggregation. Parameters of a dual network are optimized using frill lizard optimization to enhance the accuracy of attack detection. The procedure of lizard moving to catch the prey is mimicked to explore diverse regions in a large solution space to discover the potential form of solution. The simulation of retreating lizard behavior is carried out to convergence to global optimal solution. However, the results are present by considering a specific dataset which lacks the generalization capability when subjected to other networks exhibiting different characteristics. It also exhibits extreme sensitivity toward the quality of the data. The inability to handle noisy forms of data leads to performance degradation during the classification of DDoS attacks. Also, the framework is not tested in a real-time dynamic environment in which the network data distributions are subjected to change over time due to concept drift.

Afraji et al. discuss deep learning strategies to identify DDoS attacks and provide mitigating strategies for identified attacks [16]. As single-layer dense architecture fails to identify the attacks a multi-layer defense architecture is proposed. The deep learning mechanism is combined with the traditional methods to identify the nonlinear attack pattern in the traffic. Additionally, traditional methods are also retrieved to effectively apply filter for the known attacks. The mitigation strategies followed to prevent volumetric attacks include rate limiting, filtering of the malicious traffic, and establishing scrubbing centers. The deep learning architecture proposed consists of three layers: Convolutional Neural Networks (CNN), Long Short-Term Memory (LSTM), Recurrent Neural Network (RNN), and Autoencoders. CNN is responsible for analyzing the flow of the traffic and extracting spatial traffic patterns from raw form of data. LSTM and RNN incorporate the time series model to identify the attacks that might arise in the upcoming time. Autoencoders use unsupervised learning methodology to identify the anomalies in the normal traffic and raise the flag whenever deviations occur from the normal traffic. The transparency in the framework is achieving integrating the explainable AI into it. Whenever an attack is identified, the features which contributed to it such as IP patterns and traffic volumes are displayed. Proper explanation for each of the decisions made is given, which helps the experts to further refine the model which yields better accuracy. After identifying the attack, the security team will quickly isolate the attack and focus on the mitigation strategies. However, the DDoS attack detection accuracy is constrained by quality of the data and unbalanced datasets. The public dataset is considered for experiment purposes which does not encapsulate broad spectrum of the DDoS attacks. The CNN model fails to capture the temporal dependencies pattern that arises in the traffic data over time. LSTM and RNN suffer from vanishing gradient problems. Autoencoders are computationally expensive as they demand frequent fine tuning of the model to reduce false positive rates in DDoS attack detection.

Abiram Sundari et al. discuss the use of supervised learning algorithms in identifying DDoS attacks [17]. The five main supervised learning algorithms considered here for analysis are Random Forest (RF), Support Vector Machine (SVM), Logistic Regression (LR), Decision Tree (DT), and K-Nearest Neighbor (KNN). It begins with the data collection phase by considering three different categories of cybersecurity datasets. The dataset considered is composed of both labelled and unlabeled datasets covering all forms of DDoS attacks. Preprocessing of the dataset is carried out to remove duplicate and null entries. The categorial variables are converted into numerical variables using label encoding procedure. The normalization of the data is performed using standard scaler whose mean value is zero and standard deviation is 1. Also, the care is taken such that all features contribute equally to the learning process. The imbalance in the majority classes and minority classes is handled using oversampling technique. The preprocessed dataset is split into 70 percent and 30 percent. 70 percent data is used for training the model and remaining 30 percent data is used for testing the model. The dimensionality of the input dataset is reduced using principal component analysis. The five supervised classification models, i.e., RF, SVM, LR, DT, and KNN, are built. The experimental results claim that the attack detection accuracy of KNN and random forests are higher up to 98 percent. However, the DDoS attacks are recognized on offline basis and real-time analysis are not performed. The supervised learning models are computationally expensive when subjected to larger traffic datasets. It is observed that the models considered perform well over the smaller datasets and when subjected to larger datasets they suffer from overfitting problems. During the dimensionality reduction, there are higher chances of information loss leading to improper attack classifications.

Yi Li et al. present a transformer-oriented architecture for the detection of DDoS attacks considering the behavioral patterns and temporal dependency [18]. The fluctuating behavior of the network traffic is modeled by considering the temporal dependency and behavioral patterns of the traffic. First, the reconstruction of the dataset is performed through feature selection, cleaning, label encoding, normalization, and temporal sorting. The attack pattern is captured with respect to time processing the data in sliding window and positional encoding. The traffic is analyzed in three different ways which include multi head self-attention, feed forward network, and residual connections with layer normalization. The multi heads self-attention tries to capture long distance temporal dependencies by establishing the nonlinear correlations between the two-time steps of traffic. After attention mechanism, the deeper interaction patterns are extracted using two layer fully connected network. Residual connection and layer normalization are applied to each of the layers to stabilize the training process and overcome the problem of vanishing gradient. The final decision over the traffic is output by applying SoftMax operation over the fully connected header and average pooling. Model training is performed using cross entropy loss and Adam optimizer. Overfitting is prevented through early stopping procedures which terminate the training process when performance does not improve. For experiment purposes, the CIC-DDoS2019 dataset is considered to represent the dynamic nature of the attack traffic and identify the nonlinear interactions among the traffic signals. However global attention mechanism suffers from higher computational cost and complexity as it struggles to process the large-scale traffic. It is also vulnerable toward overfitting problems as twenty rounds of iterations are fixed for model training to achieve near perfect performance. It also has limited capability to capture the correlations between multiple sources of attacks.

Saswati Chatterjee et al. discussed adversarial trained graph neural networks for detection of DDoS attacks with robust optimization [19]. The dynamic form of traffic is represented as a dynamic graph which effectively captures the relational dependencies between the different IP addresses. The raw network traffic is transforming the traffic into structured format. The traffic is modeled as a dynamic graph composed of nodes, edges, and features, and to focus on the more discriminative form of data using Graph Laplacian scores. Based on the source bytes and packet rate, the traffic is classified as malicious traffic and normal traffic. The complex relational dependencies and global botnet topologies are captured using message passing paradigm in which nodes aggregates information from neighboring nodes. To enhance the robustness of the approach through adversarial training in which the traffic is perturbed to defend against the attackers. Proximal gradient strategy is employed to penalize large deviations in the model states. This also ensures smooth convergence and stabilizes the model which prevents it from overfitting to noisy adversarial examples. Experimental results demonstrate that it able to achieve stability and superior accuracy compared to standard deep learning algorithms. The security of the network is enhanced by enabling adversarial robustness with structural awareness. However, the training cost and complexity is higher due to incorporation of adversarial training along with the proximal gradient strategy. The graph topology often gets disturbed by perturbed node attributes which leads to unstable training and volatile optimization landscapes. The chances of converging to sharp local minima are more as failure in one node causes cascade of failures of neighboring nodes.

Amal Ajayan et al. presents an explainable network flow transformer for transparent identification of DDoS attacks across real world networking environment [20]. Here, the lack of transparency in decision making and endpoint leakage problem is addressed. First, the dataset is acquired, and filtering is performed to distinguish the traffic as benign traffic and DDoS traffic. After feature selection, the target labels are encoded in which 0 means benign and 1 means DDoS. An undirected graph is constructed in which IP addresses are considered nodes and network flows edges. Node level splitting is performed to make sure that the same IP address which is in training dataset comes in the testing dataset. The leakage at the cross split is prevented by discarding the network flows cross between training and testing datasets. The training dataset is balanced through random sampling, but the test dataset is left unbalanced to illustrate the dynamic deployment environment. Data cleaning and standardization are performed to ensure stability during training procedures. Principal component analysis was utilized to reduce redundancy and computational load in the dataset. The feature vectors are reshaped into sequences of vectors of fixed length. The transformer model learns the structural dependencies between the attributes by modeling the different feature groups as a sequence. The complex correlation between multiple flows is captured through multi head self-attention. Finally, the probability of DDoS attack is generated as output through fully connected neural network accompanied by the sigmoid activation function. The randomized search strategy is used to find the best configuration for the number of attention heads, encoder blocks, and learning rates. Early stopping is performed based on the Area Under the ROC Curve (AUC) on a validation set to prevent overfitting. The SHAP and LIME models were integrated to explain which features most influenced the DDoS attack. However, the dataset samples are reduced to prevent endpoint leakage which reduces the amount of usable data samples. Direct interpretability of the model is not possible due to principal component analysis of high dimensional data. Cross-network traffic validation is not performed as a result the approach cannot be generalized across different network environment. Because of adversarial vulnerability, there are chances of attacker misleading the output generated by the explainable artificial intelligence model.

The comparison of the existing works is given in

Table 1. Comparison of existing works.

Author and References	Model	Technique	Features Considered	Identical Dataset Considered for Evaluation	Performance Metrics
Jyoti Tolanur et al. [13]	Bidirectional Long Short-Term Memory + Convolutional Neural Network	Federated learning	Flow based features + Packet level features + Time series features	CIC-DDoS2019	Packet loss rate = 3.5%
					Attack detection time = 150 ms
					Attack recovery ratio = 90%
					Bandwidth utilization = 60%
					Response time = 220 ms
Hongxiang Ke et al. [14]	Cuckoo search + Bidirectional learning	Metaheuristic Learning + Deep Learning	Flow based features + Statistical features + Flag based features + Packet level features	CIC-DDoS2019	Packet loss rate = 2.8%
					Attack detection time = 120 ms
					Attack recovery ratio = 94%
					Bandwidth utilization = 78%
					Response time = 200 ms
Maghrabi et al. [15]	Dueling Double Deep Q-Network	Federated Learning + Deep Learning	Flow based features + Packet level features+ Time series features + Statistical features + Flag based features	CIC-DDoS2019	Packet loss rate = 2.5%
					Attack detection time = 95 ms
					Attack recovery ratio = 92%
					Bandwidth utilization = 82%
					Response time = 200 ms
Afraji et al. [16]	Convolutional Neural Network + Long Short-Term memory	Recurrent Neural Network + Deep Learning	Time series + Sequential features	CIC-DDoS2019	Packet loss rate = 1.8%
					Attack detection time = 85 ms
					Attack recovery ratio = 89%
					Bandwidth utilization = 88%
					Response time = 210 ms
Abiram Sundari et al. [17]	Random forest + Support vector Machine + K-Nearest Neighbors	Machine Learning + Dimensionality reduction	Principal Component Analysis + preprocessing + imbalance handling	CIC-DDoS2019	Packet loss rate = 1.5%
					Attack detection time = 59 ms
					Attack recovery ratio-85%
					Bandwidth utilization = 76%
					Response time = 180 ms
Yi Li et al. [18]	Transformer oriented architecture	Self-Attention Transformer Encoder	Flow duration, packet size, byte rate, TCP flags, source/destination IP, entropy features	CIC-DDoS2019	Packet loss rate = 2.9%
					Attack detection time = 55 ms
					Attack recovery ratio-80%
					Bandwidth utilization = 71%
					Response time = 180 ms
Saswati Chatterjee et al. [19]	adversarial trained graph neural networks	Temporal Graph Neural Network + Adversarial Learning	Time-varying communication graphs, botnet evolution patterns	CIC-DDoS2019	Packet loss rate = 2.8%
					Attack detection time = 40 ms
					Attack recovery ratio = 82%
					Bandwidth utilization = 76%
					Response time = 100 ms
Amal Ajayan et al. [20]	Explainable network flow transformer	SHAP + Deep Learning IDS	Feature importance scores, packet statistics, protocol behavior	CIC-DDoS2019	Packet loss rate = 2.2%
					Attack detection time = 59 ms
					Attack recovery ratio-85%
					Bandwidth utilization = 70%
					Response time = 120 ms
Proposed QKD framework	Knowledge Distillation + Quantum computing	Machine learning + Quantum theory	Flow based features + Packet level features+ Time series features + Statistical features + Flag based features	CIC-DDoS2019	Packet loss rate = 0.4%
					Attack detection time = 30 ms
					Attack recovery ratio = 99%
					Bandwidth utilization = 98%
					Response time = 50 ms

. The existing methods are analyzed based on methodological characteristics such as deep learning, federated learning, reinforcement learning, and hybrid quantum–machine learning approaches instead of relying solely on raw performance values.

To summarize, most of the existing works exhibit the following drawbacks:

• Deep learning models are sophisticated in nature and exhibit high computational demands. Often demand for additional feature engineering to enhance model interpretability over high dimensional data space.
• Federated learning approaches require more parameter exchanges between clients and servers leading to more commutation overhead. As the models are trained locally among several distributed cloud nodes, it causes slow convergence.
• Supervised learning algorithms exhibit high dependency over labeled datasets. Labeling the traffic patterns is time-consuming and imbalance in the dataset causes reduction in the attack detection accuracy. It mainly attempts to memorize the training patterns and as a result it fails to learn generalized patterns which ends up in overfitting problems.
• Metaheuristic methods require more iterations of training to arrive at global optimal solution. Choosing optimal parameters for tuning is important and improper selection of parameters leads to inconsistency in the attack classification. Also, it fails to capture dynamically changing behavior of DDoS attacks pattern.
• Reinforcement algorithms take longer training time to learn optimal policies through continuous interaction with the environment. When the DDoS attack pattern changes quickly, instability in learning is observed. Proper reward function design is highly important, improper reward function causes incorrect learning.
• Hybrid approaches considering metaheuristic models and deep learning models involve a greater number of parameters in fine tuning and require multiple epochs of training. High processing requirement due to intensive calculation in forward propagation, backward propagation, and evaluation of candidate solutions.

3. System Model

The system model considered for the operation of the QKD framework is explained here. The Cloud Computing System $CCS$ is composed of k number of client tasks $CT=\{{ct}_1,{ct}_2,\dots ,{ct}_k \}$, l number of data centers $DC=\left\{{dc}_1,{dc}_2,\dots ,{dc}_l \right\}$. The client tasks kept arriving in dynamic order which got stored in $M/M/m$ form. Where first $M$ = Memory less arrival process, second $M$ = memory less service process, and $m$ = parallel servers in the cloud system. Each of the data centers is composed of m number of physical machines ${DC}_i=\{{pm}_1,{pm}_2,\dots ,{pm}_m \}$. Similarly, each of the physical machines include n number of virtual machines ${pm}_i=\{{vm}_1,{vm}_2,\dots ,{vm}_n\}$. A client tasks is described as ${ct}_i=\{{ct}_{len},{ct}_{dl},{ct}_{mem},{ct}_{bw}\}$, where ${ct}_{len}$ = client task length in million instructions, ${ct}_{dl}=$ Ddeadline to complete client task, ${ct}_{mem} =$ Mmemory requirement of client task, and ${ct}_{bw}=$ Bbandwidth requirement of client task. A physical machine is described as ${pm}_i=\{{pm}_{CPU},{pm}_{RAM},{pm}_{BW},{pm}_{en}\}$, where ${pm}_{CPU}$ = CPU capacity of the physical machine, ${pm}_{RAM} =$ Mmemory capacity of the physical machine, ${pm}_{BW} =$ Bbandwidth requirement of the physical machine, and ${pm}_{en} =$ Eenergy requirement of the physical machine. Virtual machines act as logical units for executing client tasks on each of the physical machines i.e., ${vm}_i =\{{vm}_{CPU},{vm}_{RAM},{vm}_{BW},{vm}_{st}\}$, where ${vm}_{CPU} =$ CPU capacity of the virtual machine, ${vm}_{RAM} =$ Memory capacity of the virtual machine, ${vm}_{BW} =$ Bandwidth requirement of the virtual machine, and ${vm}_{st} =$ Sstorage capacity of the virtual machine. The client tasks are processed, and feature extraction is performed. The client tasks are placed in the scheduler queue $CT=\{{ct}_1,{ct}_2,\dots ,{ct}_k \}\to S(M/M/m$). The scheduler is integrated with the QKD DDoS attack detection model, which basically classifies the client tasks as normal tasks and DDOS tasks $S(M/M/m)+QKD\to \{normal, DDoS\}$. Only the normal tasks are allocated among the virtual machines for execution. Even the virtual machine also observes the client task during execution for any sort of abnormalities. Once the DDoS attack gets identified the mitigation actions will be called such as dropping of the packets, limiting the packet transfer rate, blocking the specific IP address, performing auto scaling of virtual machines, and so on. DDoS attacks have direct influence on the performance of the cloud system by causing exhaustion of physical machines and virtual machines resources. DDoS attacks do not affect a single communication link alone; rather, they simultaneously influence multiple clients, virtual machines (VMs), and physical machines (PMs) connected through shared virtualized infrastructure. Therefore, system-level performance metrics must aggregate the impact of attack behavior across multiple communication entities to accurately represent the overall operational state of the cloud system.

The mathematical definition for each of the performance metrics considered for the evaluation purpose are defined as below [21,22,23].

PM1: Packet Loss Rate $\left(PLR\left(QKD, CCS\right)\right)$: The packet loss rate is defined as the weighted product of the packet loss encountered by the by the QKD incorporated cloud model ${PLR}_{cloud}$.

$$PLR\left(QKD, CCS\right)=\lambda \ast {PLR}_{cloud}$$

(1)

where

$\lambda =$ weighing factor

${PLR}_{cloud}=$ packet loss rate at QKD incorporated cloud model, i.e., ${PLR}_{cloud}={\sum }_{i=}^k{\sum }_{j=1}^n{\sum }_{k=1}^m({\displaystyle \frac{PS\left({ct}_{i,}{vm}_j,{pm}_k\right)-PR({ct}_{i,}{vm}_j,{pm}_k)}{PS({ct}_{i,}{vm}_j,{pm}_k)}})$, $PS\left({ct}_{i,}{vm}_j,{pm}_k\right) =$ packet sent by client i to virtual machine j on physical machine k. $PR\left({ct}_{i,}{vm}_j,{pm}_k\right) =$ packet received by client i to virtual machine j on physical machine k.

PM2: Attack Detection Time $\left(ADT\left(QKD, CCS\right)\right)$: The attack detection time is defined as the weighted product of the time taken by the QKD incorporated cloud model to detect DDoS attack ${ADT}_{cloud}$.

$$ADT\left(QKD, CCS\right)=\lambda \ast {ADT}_{cloud}$$

(2)

where

$\lambda =$ Weighting factor which ranges between 0 to 1.

${ADT}_{cloud}={\displaystyle \genfrac{}{}{0pt}{}{min}{i,j,k}}$($T_{det}\left({ct}_{i,}{vm}_j,{pm}_k\right) -$ $T_{st}\left({ct}_{i,}{vm}_j,{pm}_k\right)$), $T_{det}\left({ct}_{i,}{vm}_j,{pm}_k\right)$ is the time taken to detect attack over task sent by client i to virtual machine j on physical machine k. $T_{st}\left({ct}_{i,}{vm}_j,{pm}_k\right)$ is the time during which attack begins over task sent by client i to virtual machine j on physical machine k.

PM3: Attack Recovery Ratio $\left(ARR\left(QKD, CCS\right)\right)$: Attack recovery ratio is defined as the weighted product of the attack recovery ratio of the QKD incorporated cloud model after DDoS attack ${ARR}_{cloud}$.

$$ARR\left(QKD, CCS\right)=\lambda \ast {ARR}_{cloud}$$

(3)

where

$\lambda =$ Weighting factor which ranges between 0 to 1.

${ARR}_{cloud}$ is the attack recovery ratio of the QKD incorporated cloud model after DDoS attack i.e.,

${ARR}_{cloud}={\displaystyle \frac{{\sum }_{i=}^k{\sum }_{j=1}^n{\sum }_{k=1}^m{P^{re}(ct}_{i,}{vm}_j,{pm}_k)}{{\sum }_{i=}^k{\sum }_{j=1}^n{\sum }_{k=1}^m{P^{normal}(ct}_{i,}{vm}_j,{pm}_k)}}$, ${P^{re}(ct}_{i,}{vm}_j,{pm}_k)$ is the performance after recovery from DDoS attack for client i to virtual machine j on physical machine k., ${P^{normal}(ct}_i,{vm}_j,{pm}_k)$ is the normal performance without attack for client i to virtual machine j on physical machine k.

PM4: Bandwidth Utilization $\left(BU\left(QKD, CCS\right)\right)$: Bandwidth utilization is defined as the weighted product of the actual bandwidth consumed by the QKD incorporated cloud model ${BU}_{cloud}$.

$$BU\left(QKD, CCS\right)=\lambda \ast {BU}_{cloud}$$

(4)

where

$\lambda =$ Weighting factor which ranges between 0 to 1.

${BU}_{cloud}$ is the bandwidth utilized by the QKD incorporated cloud model

PM5: Response time $\left(RT\left(QKD, CCS\right)\right)$: Response time is defined as the weighted product of the response time of the QKD incorporated cloud model.

$$RT\left(QKD, CCS\right)=\lambda \ast {RT}_{cloud}$$

(5)

${RT}_{cloud}$ is the response time of cloud model, ${RT}_{cloud}=T_{wait}+T_{proc}+T_{net}$. Where $T_{wait}$ is waiting time of client’s task, $T_{proc}$ is the processing time of the client task, and $T_{net}$ is the network transmission time.

4. Proposed Work

The high-level architecture of the QKD framework is shown in Figure 1. The novelty of the proposed work lies in the integration of quantum computing, machine learning, and knowledge distillation. A lightweight DDoS attack detection model is designed that ensure early detection of DDoS attacks in distributed cloud environment. Unlike the classical KD framework, the QKD framework reduces the model complexity and draws faster inferences with less memory overhead. The QKD compresses the learned knowledge into smaller student model that is installed in the virtual machines of cloud systems. Communication costs are reduced by reducing the need to transfer the large-scale parameters instead only distilled knowledge is transferred. The complex traffic correlation is analyzed using parameterized quantum circuits. The framework is composed of two models i.e., DDoS attack model and QKD model for identification of DDoS attacks. DDoS attackers mainly target one victim virtual machine to which high volume of client requests is sent which leads to disruption of services and wastage of resources. After finding a virtual machine as a target, an attacker creates a botnet by infecting many other clients and all these compromised clients become zombie. The attacker sends controlling commands to all infected clients so that they receive the malicious instructions simultaneously. They start transmitting large volume of requests to victim virtual machines as thousands of bots are involved. The victim virtual machines consider the malicious requests as genuine requests and try to process them. This causes overload of computation, exhaustion of memory, and bandwidth congestion. To process the huge incoming client requests the cloud system tries to automatically scale the resources. As a result, the large number of virtual machines get created with additional bandwidth and storage which leads to unnecessary use of resources. Because of the continuous attack of client requests, the application will be slow and genuine users might not be able to get their requests processed. The DDoS attack causes operational impact by increasing the cost of operation due to autoscaling and increases the downtime of services. Hence there is a need to detect the client requests that come from DDoS attackers and isolate them without processing.

The client requests patterns considering both legitimate clients and potential DDoS attackers are stored in the database of the QKD model. The information related to client requests such as source/destination source, request rate, packet size, and time interval between the client requests. The labeling of the client requests will be performed as a normal request, suspected request, and malicious requests. The labeled dataset becomes a source of dataset for training the QKD model. Further the features of the client requests are encoded into quantum states using quantum circuits with quantum data representation. The traditional CCN and LSTM perform processing of the input client requests and does encoding from classical state to quantum state. Further the encoded data is processed using parameterized quantum circuit. Angle encoding method is followed to perform mapping using Pauli Z expectation strategy. Then the quantum teacher model is trained using the stored encoded client request patterns. The quantum teacher model learns the DDoS attacker pattern and generates soft probability labels. The attack pattern will be recognized quickly using quantum encoded states. The knowledge gained by the quantum teacher model will be transferred to quantum student model. The quantum student model which is lightweight preserves the soft labelled requests patterns of the teacher. The client requests database gets updated continuously as and when new forms of DDoS attacks are detected. Further the quantum student model is optimized considering the trainable parameters from the quantum circuits. The distillation and classification loss is minimized by estimating the parameter shift gradient value. The training process begins with the feature encoding, execution of the variational circuit, measurement of expected values and updating the parameters until convergence. The parameter complexity and decision-making overhead are reduced through distilled quantum student model. The deviation between quantum teacher model and quantum student model are measure using distillation loss. Through extensive training distillation, loss is minimized so that quantum student model exactly as the quantum teacher model.

The complete quantum data flow followed during the detection of DDoS attacks using QKD framework is explained as follows. First the network traffic patterns are collected from the CIC-DDoS2019 benchmark dataset. The normalized feature vector is generated as output by applying preprocessing operations such as removal of missing values, filtering of noise, feature normalization, and feature encoding. Now the normalized form of network traffic is passed onto the CNN and LSTM models. CNN is responsible for extracting spatial traffic correlations, and mine the patterns in the packet level distributions. Similarly, LSTM extracts temporal behavior patterns and identifies long-term traffic dependencies. The main use of CNN and LSTM models is extraction of network features in robust form. The classical features are converted into quantum states through angle encoding. During the encoding stage the classical traffic features are mapped into the high dimensional quantum state. As a result, the framework can easily extract complex nonlinear traffic correlations, hidden attack patterns, correlations among various kinds of attacks, traffic dependencies, complex distribution of attacks, and many more. These benefits are not available in the conventional machine learning models. The existence of nonlinear relationships and hidden attack correlations are identified using Parameterized Quantum Circuits (PQCs). PQCs make use of the entanglement layer which helps in modeling the traffic flows which are interdependent, understand the coordination among the distributed attacks, and synchronize the behavior of the malicious traffic. It also represents the complex functions using few trainable parameters. The core part of quantum learning happens in the entanglement layer which allows the qubits to capture attacks among multiple traffic traces. The quantum data are converted to classical data using Pauli-Z measurements. Further the quantum enriched features are fed to student model which minimizes the loss through knowledge distillation. The main use of knowledge distillation is it can effectively compress the learned traffic representations into smaller and simpler forms. The student model is also lightweight and reduces the inference overhead. Finally, the category of DDoS attack is identified and displayed.

The QKD model includes both teacher and student model for DDoS attack detection. A predefined search space is defined with key parameters: CNN filters: {16, 24, 32, 33, 48, 64}, LSTM hidden units = {32, 64, 96, 128, batch size = {32, 48, 64, 65, 96, 128}, learning rate: in between $\mathbf{1}\mathbf{\ast }{\mathit{e}}^{\mathbf{-}\mathbf{2}}$ and $\mathbf{1}\mathbf{\ast }{\mathit{e}}^{\mathbf{-}\mathbf{4}}$. The CNN model is composed of following layers: Input (Feature size = 100), convolutional layer-1(CNN, filters = 33, kernel = 4, ReLU), pooling layer-1 (Maxpooling, size = 2), Convolutional layer-2 (CNN, filters = 64, Kernel = 3), LSTM (129 parameters), Dense (fully connected, 65 neurons), output (Softmax type, 2 classes parameters), loss function = cross entropy, and optimizer = Adam. Distilled student model (shallow neural network), distillation loss = KL divergence + soft labels, Temperature T > 1. Quantum model (Framework = QisKit), number of qubits = 16–32 qubits, encoding method = angle encoding, rotation gates = RX/RY/RZ, entanglement = CNOT layers, and measurement method = Pauli Z expectation. The process begins with preprocessing of the dataset, training the teacher model, and generation of soft labels. Followed with the training of student model using distillation process and evaluation over the test dataset. Hyperparameter table (Learning rate = 0.001, batch size = 65, epochs = 50, qubits = 16, circuit layers = 3, and Temperature = 3). The selection of specific values for filters and batch sizes is considered as optimal value through hyperparameter optimization over the validation part of the dataset. In specific the CNN filter = 33 generated enhanced feature diversity for all categories of DDoS traffic patterns with reduction in computational cost. Similarly batch size = 65 provided gradient stability and generalization through lower validation loss. The range of values for hyperparameters are chosen based on literature survey, computational feasibility, and validations of the experimental results. Each of the configuration parameters are evaluated by considering the validation subset of the benchmark dataset CIC-DDoS2019. Although powers-of-two values are commonly used in deep learning implementations, experimental evaluation showed that 33 filters and batch size 65 provided slightly improved convergence stability and reduced validation fluctuation for the considered CIC-DDoS2019dataset. This behavior is likely associated with dataset distribution characteristics and the hybrid CNN-LSTM-quantum architecture employed in the proposed QKD framework. The tunning study for hyperparameter optimization is shown in

Table 2. Tunning study for hyperparameter optimization.

CNN Filters	Batch Size	PLR(QKD, CC)	ADT(QKD, CC)	ARR(QKD, CC)	BU(QKD, CC)	RT(QKD, CC)
16	32	8.4	154	82.7	71.4	186
24	48	6.9	142	86.9	76.8	171
32	64	5.1	129	91.3	82.5	153
33	65	3.9	118	95.2	88.7	139
48	96	4.4	124	93.6	85.1	147
68	128	5.0	137	92.1	83.4	159

.

The main contribution of quantum models is identified as follows. The client tasks undergo nonlinear state representation. Variational quantum feature transformation and hybrid representation learning helps in arriving at quantum enhanced features. The clear discrimination between benign and malicious traffic distributions is possible. This increases the DDoS attack detection stability and traffic classification. The variational quantum circuits offer an alternative computational paradigm based on quantum superposition and entanglement, which may provide representational advantages for complex DDoS dataset. The proposed QKD framework establishes a modular foundation for future integration with higher-qubit quantum systems. Increasing the number of qubits expands the accessible quantum state space exponentially, potentially enabling richer feature encoding and improved representation of complex DDoS traffic distributions.

The detailed working of QKD is given in Algorithm 1. The algorithm is composed of quantum teacher model and quantum student model. Quantum teacher model and student model are enriched versions of the conventional teacher and student model. The quantum teacher model is responsible for generating knowledge related to DDoS attacks and quantum student model learns from the teacher model and identifies the DDoS attacks. The quantum teacher model trains the large sized quantum circuit and optimizes its parameters. A high-level representation of converting classical machine learning model output to quantum input is given in Figure 2. The quantum teacher model outputs probability distributions and measurement results. It is usually depicted as large quantum circuit which uses Pauli Z expectation to provide final qubit as output. The quantum student model learns from the quantum teacher model outputs to match the predicted probabilities and meanwhile reduces the difference value between teacher and student. The difference in the probability distributions is determined using the Kullback–Leibler divergence measure. It is not symmetrical and always nonnegative mainly aims to bring quantum student distribution closer to quantum teacher distribution. To make sure that the quantum student model mimics the output distribution probability of quantum teacher model distillation loss is measured. The parameters of the quantum teacher and student model are updated using a gradient update method so that the predications made are accurate. Instead of traditional backpropagation, parameter shift rule is applied to compute gradient values and update it accordingly. The classical models learn from hard labels whereas the quantum models learn from soft probabilities generated by the teacher model. The soft probabilities provide details of how the classes are similar/dissimilar to each other. Along with the correctness metric quantum student model also learn semantic similarity also. The soft probabilities ensure that the knowledge transfer happens seamlessly from large quantum teacher model to small quantum student model. Higher accuracy in DDoS attack detection is achieved through stabilized training. The inferences are drawn at faster space and improves the scalability of the solution by minimizing the quantum hardware cost.

Algorithm 1 Working of QKD framework

1: Start 2: Input: The set of client requests $C\mathrm{R}=\{{cr}_1,{cr}_2,{cr}_3\dots ,{cr}_m\}$$, {cr}_{\mathrm{i}}=<PR, FD, PT, SIP\_C,Avg\_PS>$, where PR is the packet rate, FD is the flow duration, PT is the protocol type, SIP_C is source IP count, Avg_PS is the average packet size. The set of cloud nodes $C{C}_N=\left\{{c{c}_n}_1,{c{c}_n}_2,{c{c}_n}_3\dots ,{c{c}_n}_m\right\}$$, {c{c}_n}_{\mathrm{i}}=\left\{{vm}_1, {vm}_2,{vm}_3\dots ,{vm}_q \right\}$$, {vm}_i=<CPU\_us,Mem, In\_tr,Ac\_con,Disk\_IO,RT>$$, \mathrm{where} CPU\_us$ is the CPU usage percentage, $Mem$ is the memory usage percentage, $In\_tr$ $\mathrm{is} \mathrm{the} \mathrm{incoming} \mathrm{traffic}, Ac\_con$ $\mathrm{is} \mathrm{the} \mathrm{active} \mathrm{connections}, Disk\_IO$ is the disk input or output, RT is the response time. 3: Output: DdoS attack detection policies $\widehat{ADP}=\{{\widehat{adp}}_1,{\widehat{adp}}_2,{\widehat{adp}}_3,\dots ..,{\widehat{adp}}_p\}$ 4: Gather the client requests from cloud system $C\mathrm{R}=\{{cr}_1,{cr}_2,{cr}_3\dots ,{cr}_m\}$ 5: Construct client requests representation$CR\_R=\{<{cr}_i,L_i>\}$$, \mathrm{where} {cr}_i$ is the client request features, $L_i$ is the label attached to the client request which can be normal client requests, and DdoS client requests. 6: Perform preprocessing operation over the client requests dataset by normalizing the client request features ${CR\_R}^{\prime }=\{<{cr}_i^{\prime },L_i^{\prime }>\}$. 7: Training of quantum teacher model 8:    Choose the high-capacity deep learning model which is hybrid form of Convolutional Neural Network (CNN) and LSTM. CNN captures spatial patterns in input traffic and LSTM captures the temporal traffic patterns. 9:    Perform training over$C\mathrm{R}=\{{cr}_1,{cr}_2,{cr}_3\dots ,{cr}_m\}$ and generate soft probability over the occurrence of DdoS attacks i.e., soft label of client requests $S{P}_{CR}=\left[Lowest probibility of DDoS attack, Highest probability of DDoS attack\right].$ 10:    Convert the client requests features into quantum representation by applying amplitude encoding $U_{ang}$ first and then refine it using angle encoding $U_{amp}$ $C\mathrm{R}=\{{cr}_1,{cr}_2,{cr}_3\dots ,{cr}_m\}\to |\mathrm{\phi }\left(C\mathrm{R}=U_{ang}\left(\left\{{cr}_1,{cr}_2,{cr}_3\dots ,{cr}_m\right\}\right)\ast U_{amp}\left(\left\{{cr}_1,{cr}_2,{cr}_3\dots ,{cr}_m\right\}\right)|0\right){>}^{\otimes n}$. 11: Stop training of quantum teacher model 12: Training of quantum student model 13:    Initialize quantum student model 14:    Design parametrized quantum circuit${\left|\mathrm{\phi }\left(\mathrm{C}\mathrm{R},\mathrm{\theta }\right)>=\mathrm{U}\left(\mathrm{\theta }\right)\mathrm{U}\left(\mathrm{C}\mathrm{R}\right)\right|0>}^{\otimes n}$$, \mathrm{where} {|0>}^{\otimes n}$ is the initial state in which n represent the number of qubits. $\mathrm{U}\left(\mathrm{C}\mathrm{R}\right)$ is the data encoding operator, $\mathrm{U}\left(\mathrm{C}\mathrm{R}\right)={\displaystyle {\prod }_{i=1}^{i=n}}{R}_y\left({cr}_{\mathrm{i}}\right)$$, R_y$ is the rotation $\mathrm{gate} \mathrm{which} \mathrm{convert} \mathrm{client} \mathrm{request} \mathrm{features} \mathrm{into} \mathrm{quantum} \mathrm{rotations}. \mathrm{U}\left(\mathrm{\theta }\right)$ is the trainable form of quantum circuit $\mathrm{U}\left(\mathrm{\theta }\right)={\prod }_{i=1}^{i=n}(U_{ent}\ast U_{rot}({\theta }_l\left)\right)$$, U_{ent}$ is the entanglement layer, and $U_{rot}$ is the rotation layer. 15:    Compute the classification loss through cross entropy $Loss\_CE\left(\theta \right)=\sum _i{L}_{i}log{P}_s\left(L_i\right|{cr}_{\mathrm{i}})$ 16:    Compute KL divergence distillation loss$Loss\_KLD(\theta )=\sum _i{P}_T^{\left(T\right)}(L_i|{cr}_{\mathrm{i}})log{\displaystyle \frac{P_T^{\left(T\right)}(L_i|{cr}_{\mathrm{i}})}{P_S^{\left(T\right)}(L_i|{cr}_{\mathrm{i}})}}$$, \mathrm{where} P_T^{\left(T\right)}=$ Teacher soft probability for the client task with temperature T, $P_S^{\left(T\right)}=$ Student soft probability for the client task with temperature T. 17:    Compute the total loss encountered $Total\_loss\left(\theta \right)=\alpha \ast Loss\_CE+\left(1-\alpha \right)\ast Loss\_KLD$ 18:    Optimize the quantum parameters${\theta }^{\ast }={\displaystyle \genfrac{}{}{0pt}{}{argmin}{\theta }}Total\_loss(\theta )$ 19:    Update the rule through gradient-based update method ${\theta }^{(t+1)}={\theta }^{\left(t\right)}-\eta {\ast \nabla }_{\theta }\ast Total\_loss(\theta )$ 20: Stop training of quantum student model 21: DdoS attack detection phase 22:    For every new client requests set $C\mathrm{R}=\{{cr}_1,{cr}_2,{cr}_3\dots ,{cr}_m\}$ 23:  Perform quantum encoding$C\mathrm{R}=\{{cr}_1,{cr}_2,{cr}_3\dots ,{cr}_m\}\to |\mathrm{\phi }\left(C\mathrm{R}=\left\{{cr}_1,{cr}_2,{cr}_3\dots ,{cr}_m\right\}\right)>$. 24:  Call parametrized quantum circuit${\left|\mathrm{\phi }\left(\mathrm{C}\mathrm{R},\mathrm{\theta }\right)>=\mathrm{U}\left(\mathrm{\theta }\right)\mathrm{U}\left(\mathrm{C}\mathrm{R}\right)\right|0>}^{\otimes n}$ 25:  Apply measurement operator i.e., Pauli Z expectation$<z>=<{\mathsf{\Psi }}_{out}\left|Z\right|{\mathsf{\Psi }}_{out}>$ 26:  Predict the client request as normal or DdoS attack ${\widehat{adp}}_i=\left\{\begin{array}{c}0, Normal client request\hfill \\ 1, DDoS attack-based client request\hfill \end{array}\right.$ 27: Stop DdoS attack detection phase 28: Output probability of the attack after measurement $y=<\mathrm{\phi }\left(\mathrm{C}\mathrm{R},\mathrm{\theta }\right)\left|M\right|\mathrm{\phi }\left(\mathrm{C}\mathrm{R},\mathrm{\theta }\right)>$, where M is the measurement operator, and $y$ is the probability of the DdoS attack. 28: Output DdoS attack detection policies $\widehat{ADP}=\{{\widehat{adp}}_1,{\widehat{adp}}_2,{\widehat{adp}}_3,\dots ..,{\widehat{adp}}_p\}$ 28: Deploy QKD model on cloud system 29: Initiate DdoS attack mitigation mechanisms i.e.,$\left\{\begin{array}{c}Block IP address\\ Drop the malicious client requests, \dots \dots \\ reallocate to the tasks to safe virtual mchines\end{array}\right.$ 30: Stop

5. Expected Value Analysis

The expected value analysis of the QKD is performed considering four performance metrics defined in the system model. Cloud computing system is composed of finite number of client tasks $\{{ct}_1,{ct}_2,\dots ,{ct}_k \}$, virtual machines $\{{vm}_1,{vm}_2,\dots ,{vm}_n\}$. The QKD model identifies the anomalies in the client tasks to generate DdoS attack detection policies $\Pi P=\{{\pi p}_{1, } \pi p_{2, },{\pi p}_{3, },\dots ,{\pi p}_{p }\}$. The performance of the QKD framework is analyzed considering three continuous time intervals i.e., $<\Delta T-\psi >,<\Delta T>, and<\Delta T+\psi >$. The outcome of the QKD framework towards performance metrics is measured in the range of low, medium, or high $O\left(QKD\right)= <Low, Medium, High>$. All heterogeneous performance metrics, both system level and model level, are normalized over a scale of 0 to 1 before doing mathematical computation. Here KL divergence is considered as indirect form of metrics which influences the performance of cloud system. Improved knowledge distillation and better alignment between quantum teacher and student models is assured through KL divergence. The performance of the proposed QKD framework is analyzed against three of the recent existing works: Federated Deep Learning FDL [13], Cuckoo Search-Bidirectional Learning CS-BL [14], Random Forest RF [17], Transformer architecture [18], adversarial graph neural network [19], and explainable network flow transformer [20]. The expected value analysis focuses on determining the average of expected outcome of decisions when different outcomes have different probabilities. All possible outcomes will be listed, and probability will be assigned to each of the outcomes. Value or payoff of each of the outcomes will be determined. The product of probability and payoff is computed for each of the possible outcomes. The sum of all outputs is the expected value estimated for the performance metrics considered for evaluation.

PM1: Packet Loss Rate $\left(\mathrm{P}\mathrm{L}\mathrm{R}\left(\mathrm{Q}\mathrm{K}\mathrm{D}\right)\right)$: The expected value of packet loos rate EV(PLR(QKD)) is dependent on the possible valued occupied by the packet loss by the QKD incorporated cloud model ${PLR}_{cloud}$.

$$EV\left({\displaystyle \frac{PLR\left(QKD\right)}{\Pi P}}, ∆T\right)={\int }_a^b{\displaystyle \frac{\sum _{aϵ\pi p}PLR\left(QKD\left(a\right)\right)}{|\Pi \mathrm{P}|}}$$

$$EV\left({\displaystyle \frac{PLR\left(QKD\right)}{\Pi \mathrm{P}}}, ∆T\right)=\sum _{d\in D}d{\int }_a^b{\displaystyle \frac{\sum _{aϵ\pi p}\lambda \ast {PLR}_{cloud}\left(a\right)}{|\Pi \mathrm{P}|}}$$

$$\begin{gathered} EV\left({\displaystyle \frac{PLR\left(QKD\right)}{\Pi \mathrm{P}}}, ∆T\right)={\displaystyle \frac{EV\left(1\ast \Pi \ast \lambda \ast {PLR}_{cloud}\right)}{P(\Pi P)}} \\ EV\left({\displaystyle \frac{PLR\left(QKD\right)}{\Pi \mathrm{P}}}, ∆T\right)={\int }_a^{b}b\ast da{\displaystyle \frac{EV\left(1\ast \Pi \ast \lambda \ast {PLR}_{cloud}\right)}{\Pi \mathrm{P}}} \end{gathered}$$

$$\mathrm{QKD}: \mathrm{EV}\left({\displaystyle \frac{PLR\left(QKD\right)}{\Pi P}}, ∆T-\psi \right)\cong Low<0, \mathrm{EV}\left({\displaystyle \frac{PLR\left(QKD\right)}{\Pi P}}, ∆T\right)\cong Low>0, \mathrm{and} \mathrm{EV}\left({\displaystyle \frac{PLR\left(QKD\right)}{\Pi P}}, ∆T+\psi \right) \cong Low>0.$$

$$\mathrm{FDL}: \mathrm{EV}\left({\displaystyle \frac{PLR\left(FDL\right)}{\Pi P}}, ∆T-\psi \right)\cong high<0, \mathrm{EV}\left({\displaystyle \frac{PLR\left(FDL\right)}{\Pi P}}, ∆T\right)\cong Medium\approx 0, \mathrm{and} \mathrm{EV}\left({\displaystyle \frac{PLR\left(FDL\right)}{\Pi P}},∆T+\psi \right)\cong high\approx 0.$$

$$\text{CS-BL}: \mathrm{EV}\left({\displaystyle \frac{PLR(CS-BL)}{\Pi P}}, ∆T-\psi \right)\cong Medium\approx 0, \mathrm{EV}\left({\displaystyle \frac{PLR(CS-BL)}{\Pi P}},∆T\right)\cong high\approx 0, \mathrm{and} \mathrm{EV}\left({\displaystyle \frac{PLR(CS-BL)}{\Pi P}},∆T+\psi \right)\cong High<0.$$

$$\mathrm{RF}: \mathrm{EV}\left({\displaystyle \frac{PLR\left(RF\right)}{\Pi P}}, ∆T-\psi \right)\cong Medium<0, \mathrm{EV}\left({\displaystyle \frac{PLR\left(RF\right)}{\Pi P}}, ∆T\right)\cong high<0, \mathrm{and} \mathrm{EV}\left({\displaystyle \frac{PLR\left(RF\right)}{\Pi P}},T+\psi \right)\cong high<0.$$

$$\mathrm{TA}: \mathrm{EV}\left({\displaystyle \frac{PLR\left(TA\right)}{\Pi P}}, ∆T-\psi \right)\cong Medium<0, \mathrm{EV}\left({\displaystyle \frac{PLR\left(TA\right)}{\Pi P}}, ∆T\right)\cong high<0, \mathrm{and} \mathrm{EV}\left({\displaystyle \frac{PLR\left(TA\right)}{\Pi P}},T+\psi \right)\cong high<0.$$

$$\text{A-GNN}: \mathrm{EV}\left({\displaystyle \frac{PLR(A-GNN)}{\Pi P}}, ∆T-\psi \right)\cong Medium<0, \mathrm{EV}\left({\displaystyle \frac{PLR(A-GNN)}{\Pi P}}, ∆T\right)\cong high<0, \mathrm{and} \mathrm{EV}\left({\displaystyle \frac{PLR(A-GNN)}{\Pi P}},T+\psi \right)\cong high<0.$$

$$\mathbf{XNFT}: \mathrm{EV}\left({\displaystyle \frac{PLR\left(XNFT\right)}{\Pi P}}, ∆T-\psi \right)\cong Medium<0, \mathrm{EV}\left({\displaystyle \frac{PLR\left(XNFT\right)}{\Pi P}}, ∆T\right)\cong high<0, \mathrm{and} \mathrm{EV}\left({\displaystyle \frac{PLR\left(XNFT\right)}{\Pi P}},T+\psi \right)\cong high<0.$$

The $EV\left(PLR\left(QKD\right)\right)$ is decreasing during <$∆T-\psi$> time interval and consistently remains lesser during <$∆T$>, and <$∆T+\psi$> time interval. The $EV\left(PLR\left(FDL\right)\right)$ is higher during <$∆T-\psi$> time interval and kept increasing during <$∆T$>, and <$∆T+\psi$>. The $EV\left(PLR\right($CS-BL)) kept increasing during time interval $<<∆T-\psi ,<∆T+\psi >$. The $EV\left(PLR\left(RF\right)\right)$ is found to be moderate during <$∆T-\psi$> time interval and kept increasing during <$∆T$>, and <$∆T+\psi$> time interval. The $EV\left(PLR\left(RF\right)\right)$ is found to be moderate during <$∆T-\psi$> time interval and kept increasing during <$∆T$>, and <$∆T+\psi$> time interval. The $EV\left(PLR\left(TA\right)\right)$ is found to be moderate during <$∆T-\psi$> time interval and kept increasing during <$∆T$>, and <$∆T+\psi$> time interval. The $EV\left(PLR\left(A-GNN\right)\right)$ is found to be moderate during <$∆T-\psi$> time interval and kept increasing during <$∆T$>, and <$∆T+\psi$> time interval. The $EV\left(PLR\left(XNFT\right)\right)$ is found to be moderate during <$∆T-\psi$> time interval and kept increasing during <$∆T$>, and <$∆T+\psi$> time interval.

PM2: Attack Detection Time $\left(\mathrm{A}\mathrm{D}\mathrm{T}\left(\mathrm{Q}\mathrm{K}\mathrm{D}\right)\right)$: The expected value of attack detection time EV(ADT(QKD)) is dependent on the possible time taken by the QKD incorporated cloud model to detect DDoS attack ${ADT}_{cloud}$.

$$EV\left({\displaystyle \frac{ADT\left(QKD\right)}{\Pi P}}, ∆T\right)={\int }_a^b{\displaystyle \frac{\sum _{aϵ\pi p}ADT\left(QKD\left(a\right)\right)}{|\Pi \mathrm{P}|}}$$

$$EV\left({\displaystyle \frac{ADT\left(QKD\right)}{\Pi \mathrm{P}}}, ∆T\right)=\sum _{d\in D}d{\int }_a^b{\displaystyle \frac{\sum _{aϵ\pi p}\ast {ADT}_{cloud}\left(a\right)}{|\Pi \mathrm{P}|}}$$

$$EV\left({\displaystyle \frac{ADT\left(QKD\right)}{\Pi \mathrm{P}}}, ∆T\right)={\displaystyle \frac{EV\left(1\ast \Pi \ast \lambda \ast {ADT}_{cloud}\right)}{P(\Pi P)}}$$

$$EV\left({\displaystyle \frac{ADT\left(QKD\right)}{\Pi \mathrm{P}}}, ∆T\right)={\int }_a^{b}b\ast da{\displaystyle \frac{\lambda \ast {ADT}_{cloud}}{\Pi \mathrm{P}}}$$

$$\mathrm{QKD}: \mathrm{EV}\left({\displaystyle \frac{ADT\left(QKD\right)}{\Pi P}}, ∆T-\psi \right)\cong Low<0, \mathrm{EV}\left({\displaystyle \frac{ADT\left(QKD\right)}{\Pi P}}, ∆T\right)\cong Low>0, \mathrm{and} \mathrm{EV}\left({\displaystyle \frac{ADT\left(QKD\right)}{\Pi P}}, ∆T+\psi \right) \cong Low>0.$$

$$\mathrm{FDL}: \mathrm{EV}\left({\displaystyle \frac{ADT\left(FDL\right)}{\Pi P}}, ∆T-\psi \right)\cong Medium<0, \mathrm{EV}\left({\displaystyle \frac{ADT\left(FDL\right)}{\Pi P}}, ∆T\right)\cong Medium\approx 0, \mathrm{and} \mathrm{EV}\left({\displaystyle \frac{ADT\left(FDL\right)}{\Pi P}},∆T+\psi \right)\cong high\approx 0.$$

$$\text{CS-BL}: \mathrm{EV}\left({\displaystyle \frac{ADT(CS-BL)}{\Pi P}}, ∆T-\psi \right)\cong High\approx 0, \mathrm{EV}\left({\displaystyle \frac{ADT(CS-BL)}{\Pi P}},∆T\right)\cong high\approx 0, \mathrm{and} \mathrm{EV}\left({\displaystyle \frac{ADT(CS-BL)}{\Pi P}},∆T+\psi \right)\cong High<0.$$

$$\mathrm{RF}: \mathrm{EV}\left({\displaystyle \frac{ADT\left(RF\right)}{\Pi P}}, ∆T-\psi \right)\cong Medium<0, \mathrm{EV}\left({\displaystyle \frac{ADT\left(RF\right)}{\Pi P}}, ∆T\right)\cong high<0, \mathrm{and} \mathrm{EV}\left({\displaystyle \frac{ADT\left(RF\right)}{\Pi P}},∆T+\psi \right)\cong high<0.$$

$$\mathrm{TA}: \mathrm{EV}\left({\displaystyle \frac{ADT\left(TA\right)}{\Pi P}}, ∆T-\psi \right)\cong Medium<0, \mathrm{EV}\left({\displaystyle \frac{ADT\left(TA\right)}{\Pi P}}, ∆T\right)\cong high<0, \mathrm{and} \mathrm{EV}\left({\displaystyle \frac{ADT\left(TA\right)}{\Pi P}},∆T+\psi \right)\cong high<0.$$

$$\text{A-GNN}: \mathrm{EV}\left({\displaystyle \frac{ADT(A-GNN)}{\Pi P}}, ∆T-\psi \right)\cong Medium<0, \mathrm{EV}\left({\displaystyle \frac{ADT(A-GNN)}{\Pi P}}, ∆T\right)\cong high<0, \mathrm{and} \mathrm{EV}\left({\displaystyle \frac{ADT(A-GNN)}{\Pi P}},∆T+\psi \right)\cong high<0.$$

$$\mathrm{XNFT}: \mathrm{EV}\left({\displaystyle \frac{ADT\left(XNFT\right)}{\Pi P}}, ∆T-\psi \right)\cong Medium<0, \mathrm{EV}\left({\displaystyle \frac{ADT\left(XNFT\right)}{\Pi P}}, ∆T\right)\cong high<0, \mathrm{and} \mathrm{EV}\left({\displaystyle \frac{ADT\left(XNFT\right)}{\Pi P}},∆T+\psi \right)\cong high<0.$$

The $EV\left(ADT\left(QKD\right)\right)$ is decreasing during <$∆T-\psi$> time interval and consistently remains lesser during <$∆T$>, and <$∆T+\psi$> time interval. The $EV\left(ADT\left(FDL\right)\right)$ is medium during $<<∆T-\psi , ∆T>$ time interval and kept increasing during <$∆T+\psi$> time interval. The $EV\left(ADT\right(C$S-BL)) is consistently high during time interval $<∆T-\psi ,<∆T+\psi >$. The $EV\left(ADT\left(RF\right)\right)$ is found to be moderate during $<∆T-\psi , ∆T$> time interval and kept increasing during <$∆T+\psi$> time interval. The $EV\left(ADT\left(TA\right)\right)$ is found to be moderate during $<∆T-\psi , ∆T$> time interval and kept increasing during <$∆T+\psi$> time interval. The $EV\left(ADT\left(A-GNN\right)\right)$ is found to be moderate during $<∆T-\psi , ∆T$> time interval and kept increasing during <$∆T+\psi$> time interval. The $EV\left(ADT\left(XNFT\right)\right)$ is found to be moderate during $<∆T-\psi , ∆T$> time interval and kept increasing during <$∆T+\psi$> time interval.

PM3: Attack Recovery Ratio $\left(\mathrm{A}\mathrm{R}\mathrm{R}\left(\mathrm{Q}\mathrm{K}\mathrm{D}\right)\right)$: The expected value of attack recovery ratio EV(ARR(QKD)) is dependent on the possible value occupied by the attack recovery ratio of QKD incorporated cloud model after DDoS attack ${ARR}_{cloud}$.

$$EV\left({\displaystyle \frac{ARR\left(QKD\right)}{\Pi P}}, ∆T\right)={\int }_a^b{\displaystyle \frac{\sum _{aϵ\pi p}ARR\left(QKD\left(a\right)\right)}{|\Pi \mathrm{P}|}}$$

$$EV\left({\displaystyle \frac{ARR\left(QKD\right)}{\Pi P}}, ∆T\right)=\sum _{d\in D}d{\int }_a^b{\displaystyle \frac{\sum _{aϵ\pi p}\ast \lambda \ast {ARR}_{cloud}\left(a\right)}{|\Pi \mathrm{P}|}}$$

$$EV\left({\displaystyle \frac{ARR\left(QKD\right)}{\Pi \mathrm{P}}}, ∆T\right)={\displaystyle \frac{EV\left(1\ast \Pi \ast \lambda \ast {ARR}_{cloud}\right)}{P(\Pi P)}}$$

$$EV\left({\displaystyle \frac{ARR\left(QKD\right)}{\Pi \mathrm{P}}}, ∆T\right)={\int }_a^{b}b\ast da{\displaystyle \frac{\lambda \ast {ARR}_{cloud}}{\Pi \mathrm{P}}}$$

$$\mathrm{QKD}: \mathrm{EV}\left({\displaystyle \frac{ARR\left(QKD\right)}{\Pi P}}, ∆T-\psi \right)\cong High<0, \mathrm{EV}\left({\displaystyle \frac{ARR\left(QKD\right)}{\Pi P}}, ∆T\right)\cong High>0, \mathrm{and} \mathrm{EV}\left({\displaystyle \frac{ARR\left(QKD\right)}{\Pi P}}, ∆T+\psi \right) \cong High>0.$$

$$\mathrm{FDL}: \mathrm{EV}\left({\displaystyle \frac{ARR\left(FDL\right)}{\Pi P}}, ∆T-\psi \right)\cong Medium<0, \mathrm{EV}\left({\displaystyle \frac{ARR\left(FDL\right)}{\Pi P}}, ∆T\right)\cong Low\approx 0, \mathrm{and} \mathrm{EV}\left({\displaystyle \frac{ARR\left(FDL\right)}{\Pi P}},∆T+\psi \right)\cong Low\approx 0.$$

$$\text{CS-BL}: \mathrm{EV}\left({\displaystyle \frac{ARR(CS-BL)}{\Pi P}}, ∆T-\psi \right)\cong Medium\approx 0, \mathrm{EV}\left({\displaystyle \frac{ARR(CS-BL)}{\Pi P}},∆T\right)\cong Medium\approx 0, \mathrm{and} \mathrm{EV}\left({\displaystyle \frac{ARR(CS-BL)}{\Pi P}},∆T+\psi \right)\cong Medium<0.$$

$$\mathrm{RF}: \mathrm{EV}\left({\displaystyle \frac{ARR\left(RF\right)}{\Pi P}}, ∆T-\psi \right)\cong High<0, \mathrm{EV}\left({\displaystyle \frac{ARR\left(RF\right)}{\Pi P}}, ∆T\right)\cong Medium<0, \mathrm{and} \mathrm{EV}\left({\displaystyle \frac{ARR\left(RF\right)}{\Pi P}},∆T+\psi \right)\cong Low<0.$$

$$\mathrm{TA}: \mathrm{EV}\left({\displaystyle \frac{ARR\left(TA\right)}{\Pi P}}, ∆T-\psi \right)\cong High<0, \mathrm{EV}\left({\displaystyle \frac{ARR\left(TA\right)}{\Pi P}}, ∆T\right)\cong Medium<0, \mathrm{and} \mathrm{EV}\left({\displaystyle \frac{ARR\left(TA\right)}{\Pi P}},∆T+\psi \right)\cong Low<0.$$

$$\text{A-GNN}: \mathrm{EV}\left({\displaystyle \frac{ARR(A-GNN)}{\Pi P}}, ∆T-\psi \right)\cong High<0, \mathrm{EV}\left({\displaystyle \frac{ARR(A-GNN)}{\Pi P}}, ∆T\right)\cong Medium<0, \mathrm{and} \mathrm{EV}\left({\displaystyle \frac{ARR(A-GNN)}{\Pi P}},∆T+\psi \right)\cong Low<0.$$

$$\mathrm{XNFT}: \mathrm{EV}\left({\displaystyle \frac{ARR\left(XNFT\right)}{\Pi P}}, ∆T-\psi \right)\cong High<0, \mathrm{EV}\left({\displaystyle \frac{ARR\left(XNFT\right)}{\Pi P}}, ∆T\right)\cong Medium<0, \mathrm{and} \mathrm{EV}\left({\displaystyle \frac{ARR\left(XNFT\right)}{\Pi P}},∆T+\psi \right)\cong Low<0.$$

The $EV\left(ARR\left(QKD\right)\right)$ is higher during $<∆T-\psi$> time interval and consistently remains higher during <$∆T$>, and <$∆T+\psi$> time interval. The $EV\left(ARR\left(FDL\right)\right)$ is medium during $<∆T-\psi ,>$ time interval and kept decreasing during <$∆T,∆T+\psi$> time interval. The $EV\left(ARR\right(C$S-BL)) is consistently moderate during time interval $<∆T-\psi ,<∆T+\psi >$. The $EV\left(ARR\left(RF\right)\right)$ is found to be higher during $<∆T-\psi >$ time interval and kept decreasing during <<$∆T, ∆T+\psi$> time interval. The $EV\left(ARR\left(RF\right)\right)$ is found to be higher during $<∆T-\psi >$ time interval and kept decreasing during <<$∆T, ∆T+\psi$> time interval. The $EV\left(ARR\left(TA\right)\right)$ is found to be higher during $<∆T-\psi >$ time interval and kept decreasing during <<$∆T, ∆T+\psi$> time interval. The $EV\left(ARR\left(A-GNN\right)\right)$ is found to be higher during $<∆T-\psi >$ time interval and kept decreasing during <<$∆T, ∆T+\psi$> time interval. The $EV\left(ARR\left(XNFT\right)\right)$ is found to be higher during $<∆T-\psi >$ time interval and kept decreasing during <<$∆T, ∆T+\psi$> time interval.

PM4: Bandwidth Utilization $\left(\mathrm{B}\mathrm{U}\left(\mathrm{Q}\mathrm{K}\mathrm{D}\right)\right)$: The expected value of bandwidth utilization EV(BU(QKD)) is dependent on the possible value occupied by the actual bandwidth consumed by the QKD incorporated cloud model ${BU}_{cloud}$.

$$EV\left({\displaystyle \frac{BU\left(QKD\right)}{\Pi P}}, ∆T\right)={\int }_a^b{\displaystyle \frac{\sum _{aϵ\pi p}BU\left(QKD\left(a\right)\right)}{|\Pi \mathrm{P}|}}$$

$$=\sum _{d\in D}d{\int }_a^b{\displaystyle \frac{\sum _{aϵ\pi p}\ast \lambda \ast {BU}_{cloud}\left(a\right)}{|\Pi \mathrm{P}|}}$$

$$EV\left({\displaystyle \frac{BU\left(QKD\right)}{\Pi \mathrm{P}}}, ∆T\right)={\displaystyle \frac{EV\left(1\ast \Pi \ast \lambda \ast {BU}_{cloud}\right)}{P(\Pi P)}}$$

$$EV\left({\displaystyle \frac{BU\left(QKD\right)}{\Pi \mathrm{P}}}, ∆T\right)={\int }_a^{b}b\ast da{\displaystyle \frac{\lambda \ast {BU}_{cloud}}{\Pi \mathrm{P}}}$$

$$\mathrm{QKD}: \mathrm{EV}\left({\displaystyle \frac{BU\left(QKD\right)}{\Pi P}}, ∆T-\psi \right)\cong High<0, \mathrm{EV}\left({\displaystyle \frac{BU\left(QKD\right)}{\Pi P}}, ∆T\right)\cong High>0, \mathrm{and} \mathrm{EV}\left({\displaystyle \frac{BU\left(QKD\right)}{\Pi P}}, ∆T+\psi \right) \cong High>0.$$

$$\mathrm{FDL}: \mathrm{EV}\left({\displaystyle \frac{BU\left(FDL\right)}{\Pi P}}, ∆T-\psi \right)\cong Medium<0, \mathrm{EV}\left({\displaystyle \frac{BU\left(FDL\right)}{\Pi P}}, ∆T\right)\cong Low\approx 0, \mathrm{and} \mathrm{EV}\left({\displaystyle \frac{BU\left(FDL\right)}{\Pi P}},∆T+\psi \right)\cong Low\approx 0.$$

$$\text{CS-BL}: \mathrm{EV}\left({\displaystyle \frac{BU(CS-BL)}{\Pi P}}, ∆T-\psi \right)\cong Low\approx 0, \mathrm{EV}\left({\displaystyle \frac{BU(CS-BL)}{\Pi P}},∆T\right)\cong Low\approx 0, \mathrm{and} \mathrm{EV}\left({\displaystyle \frac{BU(CS-BL)}{\Pi P}},∆T+\psi \right)\cong Low<0.$$

$$\mathrm{RF}: \mathrm{EV}\left({\displaystyle \frac{BU\left(RF\right)}{\Pi P}}, ∆T-\psi \right)\cong High<0, \mathrm{EV}\left({\displaystyle \frac{BU\left(RF\right)}{\Pi P}}, ∆T\right)\cong Medium<0, \mathrm{and} \mathrm{EV}\left({\displaystyle \frac{BU\left(RF\right)}{\Pi P}},∆T+\psi \right)\cong Medium<0.$$

$$\mathrm{TA}: \mathrm{EV}\left({\displaystyle \frac{BU\left(TA\right)}{\Pi P}}, ∆T-\psi \right)\cong High<0, \mathrm{EV}\left({\displaystyle \frac{BU\left(TA\right)}{\Pi P}}, ∆T\right)\cong Medium<0, \mathrm{and} \mathrm{EV}\left({\displaystyle \frac{BU\left(TA\right)}{\Pi P}},∆T+\psi \right)\cong Medium<0.$$

$$\text{A-GNN}: \mathrm{EV}\left({\displaystyle \frac{BU(A-GNN)}{\Pi P}}, ∆T-\psi \right)\cong Low<0, \mathrm{EV}\left({\displaystyle \frac{BU(A-GNN)}{\Pi P}}, ∆T\right)\cong Medium<0, \mathrm{and} \mathrm{EV}\left({\displaystyle \frac{BU(A-GNN)}{\Pi P}},∆T+\psi \right)\cong Medium<0.$$

$$\mathrm{XNFT}: \mathrm{EV}\left({\displaystyle \frac{BU\left(XNFT\right)}{\Pi P}}, ∆T-\psi \right)\cong High<0, \mathrm{EV}\left({\displaystyle \frac{BU\left(XNFT\right)}{\Pi P}}, ∆T\right)\cong Medium<0, \mathrm{and} \mathrm{EV}\left({\displaystyle \frac{BU\left(XNFT\right)}{\Pi P}},∆T+\psi \right)\cong Medium<0.$$

The $EV\left(BU\left(QKD\right)\right)$ is higher during <$∆T-\psi$> time interval and consistently remains higher during <$∆T$>, and <$∆T+\psi$> time interval. The $EV\left(BU\left(FDL\right)\right)$ is medium during $<∆T-\psi ,>$ time interval and kept decreasing during <$∆T,∆T+\psi$> time interval. The $EV\left(BU\right(CS-BL$)) is consistently low during time interval $<∆T-\psi ,<∆T+\psi >$. The $EV\left(BU\left(RF\right)\right)$ is found to be higher during $<∆T-\psi >$ time interval and is found to be moderate during <<$∆T, ∆T+\psi$> time interval. The $EV\left(BU\left(TA\right)\right)$ is found to be higher during $<∆T-\psi >$ time interval and is found to be moderate during <<$∆T, ∆T+\psi$> time interval. The $EV\left(BU\left(A-GNN\right)\right)$ is found to be higher during $<∆T-\psi >$ time interval and is found to be moderate during <<$∆T, ∆T+\psi$> time interval. The $EV\left(BU\left(XNFT\right)\right)$ is found to be higher during $<∆T-\psi >$ time interval and is found to be moderate during <<$∆T, ∆T+\psi$> time interval.

PM5: Response Time $\left(\mathrm{R}\mathrm{T}\left(\mathrm{Q}\mathrm{K}\mathrm{D}\right)\right)$: The expected value of the response time EV(RT(QKD)) is dependent on the possible value occupied by the response time of the QKD incorporated cloud model ${RT}_{cloud}$.

$$EV\left({\displaystyle \frac{RT\left(QKD\right)}{\Pi P}}, ∆T\right)={\int }_a^b{\displaystyle \frac{\sum _{aϵ\pi p}RT\left(QKD\left(a\right)\right)}{|\Pi \mathrm{P}|}}$$

$$=\sum _{d\in D}d{\int }_a^b{\displaystyle \frac{\sum _{aϵ\pi p}\ast \lambda \ast {RT}_{cloud}\left(a\right)}{|\Pi \mathrm{P}|}}$$

$$EV\left({\displaystyle \frac{RT\left(QKD\right)}{\Pi \mathrm{P}}}, ∆T\right)={\displaystyle \frac{EV\left(1\ast \Pi \ast \lambda \ast {RT}_{cloud}\right)}{P(\Pi P)}}$$

$$EV\left({\displaystyle \frac{RT\left(QKD\right)}{\Pi \mathrm{P}}}, ∆T\right)={\int }_a^{b}b\ast da{\displaystyle \frac{\lambda \ast {RT}_{cloud}}{\Pi \mathrm{P}}}$$

$$\mathrm{QKD}: \mathrm{EV}\left({\displaystyle \frac{RT\left(QKD\right)}{\Pi P}}, ∆T-\psi \right)\cong Low<0, \mathrm{EV}\left({\displaystyle \frac{RT\left(QKD\right)}{\Pi P}}, ∆T\right)\cong Low>0, \mathrm{and} \mathrm{EV}\left({\displaystyle \frac{RT\left(QKD\right)}{\Pi P}}, ∆T+\psi \right) \cong Low>0.$$

$$\mathrm{FDL}: \mathrm{EV}\left({\displaystyle \frac{RT\left(FDL\right)}{\Pi P}}, ∆T-\psi \right)\cong Medium<0, \mathrm{EV}\left({\displaystyle \frac{RT\left(FDL\right)}{\Pi P}}, ∆T\right)\cong Medium\approx 0, \mathrm{and} \mathrm{EV}\left({\displaystyle \frac{RT\left(FDL\right)}{\Pi P}},∆T+\psi \right)\cong High\approx 0.$$

$$\text{CS-BL}: \mathrm{EV}\left({\displaystyle \frac{RT(CS-BL)}{\Pi P}}, ∆T-\psi \right)\cong Medium\approx 0, \mathrm{EV}\left({\displaystyle \frac{RT(CS-BL)}{\Pi P}},∆T\right)\cong Medium\approx 0, \mathrm{and} \mathrm{EV}\left({\displaystyle \frac{RT(CS-BL)}{\Pi P}},∆T+\psi \right)\cong Medium<0.$$

$$\mathrm{RF}: \mathrm{EV}\left({\displaystyle \frac{RT\left(RF\right)}{\Pi P}}, ∆T-\psi \right)\cong High<0, \mathrm{EV}\left({\displaystyle \frac{RT\left(RF\right)}{\Pi P}}, ∆T\right)\cong Medium<0, \mathrm{and} \mathrm{EV}\left({\displaystyle \frac{RT\left(RF\right)}{\Pi P}},∆T+\psi \right)\cong Medium<0.$$

$$\mathrm{TA}: \mathrm{EV}\left({\displaystyle \frac{RT\left(TA\right)}{\Pi P}}, ∆T-\psi \right)\cong High<0, \mathrm{EV}\left({\displaystyle \frac{RT\left(TA\right)}{\Pi P}}, ∆T\right)\cong Medium<0, \mathrm{and} \mathrm{EV}\left({\displaystyle \frac{RT\left(TA\right)}{\Pi P}},∆T+\psi \right)\cong High<0.$$

$$\text{A-GNN}: \mathrm{EV}\left({\displaystyle \frac{RT(A-GNN)}{\Pi P}}, ∆T-\psi \right)\cong High<0, \mathrm{EV}\left({\displaystyle \frac{RT(A-GNN)}{\Pi P}}, ∆T\right)\cong High<0, \mathrm{and} \mathrm{EV}\left({\displaystyle \frac{RT(A-GNN)}{\Pi P}},∆T+\psi \right)\cong Medium<0.$$

$$\mathrm{XNFT}: \mathrm{EV}\left({\displaystyle \frac{RT\left(XNFT\right)}{\Pi P}}, ∆T-\psi \right)\cong High<0, \mathrm{EV}\left({\displaystyle \frac{RT\left(XNFT\right)}{\Pi P}}, ∆T\right)\cong Medium<0, \mathrm{and} \mathrm{EV}\left({\displaystyle \frac{RT\left(XNFT\right)}{\Pi P}},∆T+\psi \right)\cong High<0.$$

The $EV\left(RT\left(QKD\right)\right)$ is consistently low during <$∆T-\psi , ∆T+\psi$> time interval. The $EV\left(RT\left(FDL\right)\right)$ is medium during <$∆T-\psi , ∆T>$ time interval and kept increasing during <$∆T+\psi$> time interval. The $EV\left(RT\right(C$S-BL)) is found to be consistently in medium range during time interval $<∆T-\psi ,<∆T+\psi >$. The $EV\left(RT\left(RF\right)\right)$ is found to be higher during <$∆T-\psi , ∆T$> time interval and kept in medium range during <$∆T+\psi$> time interval. The $EV\left(RT\left(TA\right)\right)$ is found to be higher during <$∆T-\psi , ∆T$> time interval and kept in medium range during <$∆T+\psi$> time interval. The $EV\left(RT\left(A-GNN\right)\right)$ is found to be higher during <$∆T-\psi , ∆T$> time interval and kept in medium range during <$∆T+\psi$> time interval. The $EV\left(RT\left(XNFT\right)\right)$ is found to be higher during <$∆T-\psi , ∆T$> time interval and kept in medium range during <$∆T+\psi$> time interval.

6. Results and Discussion

The performance of the proposed QKD framework is simulated using DynamicCloudSim 3.0.3 simulator and Qiskit module composed of finite number of user requests, physical machines, and virtual machines [24]. Since DynamicCloudSim is a java-based simulator, it does not support the design and evaluation of quantum circuits. Therefore, the Qiskit module which is python-based is combined with the Representational State Transfer (REST) API interface. The feature vectors are extracted using DynamicCloudSim and sent to the QiSkit for further operation. The QiSkit service perform quantum feature encoding and draw the inferences based on the state vector results. The results are sent to DynamicCloudSim for the purpose of evaluation and validation. First the DynamicCloudSim simulator extracts the network traffic flows from simulated network environment. The extracted traffic features are normalized into JavaScript Object Notation (JSON) format. The Hypertext Transfer Protocol (HTTP) POST requests will be sent to Qiskit server. Qiskit is responsible for processing the requests received using the QKD model. The quantum inference outputs in terms of classification probabilities and decision labels will be returned to DynamicCloudSim as a response of HTTP. The performance of the proposed QKD framework is compared with three of the recent existing baselines i.e., Federated Deep Learning FDL [13], Cuckoo Search-Bidirectional Learning CS-BL [14], Random Forest RF [17], Transformer architecture [18], adversarial graph neural network [19], and explainable network flow transformer [20]. The implementation details for baselines are initialized as follows: Federated Deep Learning FDL (Learning rate = 0.001, optimizer = Adam, batch size = 64, epochs = 50, activation function = ReLU, loss function = categorical cross entropy, dropout = 0.3, federated rounds = 20). Cuckoo Search-Bidirectional Learning CS-BL (Regularization = L2, Solver = liblinear, Max iterations = 1000, Kernel = Radial Basis Function (RBF), Gamma = scale). Random Forest RF (Number of trees = 100, Maximum depth = 20, Criterion = Gini, Minimum samples split = 2, Minimum samples leaf = 1, Bootstrap = True). Transformer architecture (Learning rate = 0.01, batch size = 64, encoder layers = 4, attention heads = 8, embedding dimension = 120, dropout = 0.3, sequence length = 256). Adversarial Graph Neural Network (Learning rate = 0.001, Number of GNN layers = 5 layers, Hidden dimension size = 500, batch size = 100, dropout = 0.5, epochs = 500). Explainable Network Flow Transformer (Learning rate = 0.001, batch size = 64, encoder layers = 4, attention heads = 8, embedding dimension = 128, feedforward dimension = 512, dropout = 0.3, sequence length = 256, epochs = 150, explanation samples = 200).

The performance metric computation procedure is detailed as follows: Packet loss rate is the difference between the packet’s transmitted by the sender and successful count of packets received at the destination. The packet difference is converted into percentage. Higher packet loss rate represents severe congestion and lower packet loss ratee represent better network reliability. Attack detection time is the difference in timestamp between the beginning of attack traffic and alert raised by the QKD framework. Smaller attack detection time represents the faster detection of the attack and higher attack detection time represents the delayed time in attack detection. Attack recovery ratio measures the successful restoring of the resources after the DDoS attack. Higher ratio of attack recovery represents better resilience and lower attack recovery ratio represents poor recovery capacity. Bandwidth utilization is the measure of network bandwidth consumption by the QKD model. Unnecessary bandwidth utilization is prevented through early detection of DDoS attacks. Response time is the measure of the time difference between input submission and completion. Lesser response time represents the good Quality of Service (QoS) and higher response time represents poor QoS.

The parameters (data centers, virtual machine, client tasks, attack pattern, QKD parameters) within the simulator are initialized as follows. The parameters of data centers are initialized as follows: Number of data centers = 5 data centers, number of hosts considered for every data center = 12, RAM capability of host = 18 GB, storage capacity = 1 TB, number of processing elements = 8 cores, each core millions of operations per second = 1000 MIPS. The parameters of the virtual machines are initialized as follows: Number of virtual machines = 20–100, Ram capability of virtual machine = 3048 MB, bandwidth capability of the virtual machine = 1000 Mbps, image size of virtual machine = 10 GB, scheduler used by the virtual machine = Time shared. The parameters of the client tasks are initialized as follows: Number of client tasks = 100–2000, length of client task = 10,000–60,000 MI, input size of the client task = 500 Bytes, and output size if the client task = 500 Bytes. The malicious client tasks are responsible for generating the DDoS traffic to provide training for QKD framework regarding abnormal behavior of the traffic. The type of attack considered = flooding-based DDoS, percentage of virtual machines attacked = 10–50% of virtual machines, rate of traffic generated by client requests = high burst of traffic, duration of DDoS attack = random time intervals. The parameters of teacher model are initialized as follows: type of teacher model = Convolutional Neural Network + Long Short-Term Memory (LSTM), number of layers in the knowledge distillation framework = 6–12 layers, number of training epochs = 50–200. Quantum feature encoding is performed using Qiskit tool which is popular opensource toolkit designed by IBM and Qubit count = 16–32 qubits. Distillation loss function = cross-entropy loss and KL divergence loss. The parameters of student model are initialized as follows: type of student model = Lightweight Artificial Neural Network (ANN), number of layers in the ANN = 3–5 layers, inference time = low latency, and deployment model = broker level [25]. The benchmark dataset used for experiment validation is CIC-DDoS2019, it is one of the benchmark datasets considered for detection and mitigation of DDoS attacks. The dataset is developed by Canadian Institute for Cybersecurity which is used for simulation of DDoS attacks in networking environment. It is composed of millions of network flows which get generated over multiple days of traffic. The feature types collected include flow-based feature, time-based feature, statistical features, and flag-based features. Eighty different types of features are extracted from the dataset using CICFlowMeter. The attack types considered include both volumetric attacks and protocol attacks. As the dataset includes large number of attack samples and normal samples it is sampled using Synthetic Minority Over-sampling Technique. 70 percent of dataset is used for training and remaining 30 percent is used for testing, and validation is performed through 5-fold validation technique. The CIC-DDoS2019 dataset preprocessing pipeline is applied to all baseline methods. Cross-validation or train-test splits (80–20%) were consistently maintained. Hyperparameter optimization technique, i.e., Bayesian optimization is employed. To ensure fairness in comparison identical optimization settings and evaluation protocol is followed. Hence Bayesian optimization is applied for proposed QKD and all baseline methods.

The CIC-DDoS2019 dataset consists of various kinds of network traffic which include normal traffic, SYN flooding, User Datagram Protocol (UDP) flooding, Lightweight Directory Access Protocol (LDAP) attacks, Network Basic Input/Output System (NetBIOS) attacks, Domain Name System (DNS) attacks, Microsoft SQL Server (MSSQL) attacks, and Simple Service Discovery Protocol (SSDP) attacks. The dataset is highly imbalanced as certain types of traffic generate larger traffic volumes compared to another. Normal traffic samples are few, amplification attacks are more. To ensure balanced learning the dataset is analyzed properly with respect to majority and minority classes of attacks. Controlled sampling of traffic is performed using undersampling and oversampling methodologies. Minority classes are enhanced using Synthetic Minority Over-sampling Technique (SMOTE). Cross validation of the fairness is provided through stratifies training and splitting followed up with the validation. The stable training ensures the stability of the PQC by preventing the dominant class of attacks on influencing the quantum feature representations. All extracted features from CIC-DDoS 2019 dataset do not contribute equally to DDoS attack detection. So, features like flow duration, packet rate, forward packet length, backward packet length, and flow byte rate, average packet size, and bandwidth utilization ratio are considered. The optimized features are supplied to CNN and LSTM teacher model which goes into quantum encoding stage for further actions. The leakage of data is prevented by properly dividing the dataset, i.e., 70 percentage for training, 15 percentage for validation, and remaining 15 percentage for testing purposes. Feature normalization of parameters is performed only for training data and then subsequently it is applied to validation and testing part of the dataset. Each experiment was independently repeated multiple times (5–10 runs) under identical conditions, and the average metric values were reported. Statistical significance analysis was performed using paired t-tests with $p<0.05$ to verify that the observed improvements were not due to random variation.

• PM1: Packet Loss Rate (PLR(QKD, CCS))

A graph of time versus packet loss rate is shown in Figure 3. It is observed from the graph that the packet loss rate of QKD is consistently less, i.e., 20 percent with respect to time because the quantum student model can achieve teachers’ accuracy with lesser training on fewer resources. Whereas the packet loss rate of FDL is very high, i.e., 80 percent with respect to time due to reduced accuracy because of poor global and local learning capability. The packet loss rate of CS-BL is found to be moderate, i.e., 50 percent with respect to time as it gets trapped in local optimal solution due to poor exploration of the search space. The packet loss rate of RF is also found to be higher, i.e., 80 percent with respect to time as the chances of learning wrong pattern are high when the training data includes noise. The packet loss rate of TA is also found to be higher, i.e., 81 percent due to training instability and loss of long-term dependencies. The packet loss rate of A-GNN is also found to be above moderate, i.e., 70 percent as the node embeddings are too similar Malicious and benign traffic become indistinguishable. The packet loss rate of XNFT is also found to be higher, i.e., 80 percent due to poor generalization as the explanations are depended on training data, feature distributions, and the quality of preprocessing.

2.

PM2: Attack Detection Time (ADT(QKD, CCS))

A graph of the number of client tasks versus attack detection time is shown in Figure 4. It is observed from the graph that the attack detection time of QKD is consistently less, i.e., 40 ms as the distillation allows for smaller student model to learn from larger teacher model with reduced circuit depth and number of quantum gates. The attack detection time of FDL kept increasing with the increase in the number of client tasks, i.e., 150 ms due to lower convergence time because of multiple conversions between client and server. The attack detection time of CS-BL is very high, i.e., 200 ms as optimization is highly sensitive towards choice of parameters like step size and discovery probability. The attack detection time of RF consistently remained higher, i.e., 250 ms over the increase in the number of client tasks as the entire forest needs to be rebuilt when characteristics of client tasks change. The attack detection time of TA consistently remained to be higher i.e., 210 ms due to inference delay and processing bottlenecks. The attack detection time of A-GNN consistently remained to be above moderate, i.e., 200 ms due to inefficient handling of massive communication graphs. The attack detection time of XNFT consistently remained to be higher, i.e., 220 ms due to overhead of continuous traffic monitoring and low latency decisions.

3.

PM3: Attack Recovery Ratio (ARR(QKD, CCS))

A graph of percentage of malicious client tasks versus attack recovery ratio is shown in Figure 5. The attack recovery ratio of QKD is very high 99 percent with the increase in the percentage of malicious client tasks as it prevents overfitting by learning hidden patterns through soft probability distributions. The attack recovery ratio of FDL is found to be moderate, i.e., 50 percent as heterogenous data distribution leads to unstable learning. The attack recovery ratio of CS-BL is less, i.e., 40 percent as it exhibits poor performance for larger state space due to random search mechanisms. The attack recovery ratio of RF is found to be very low, i.e., 30 percent as the existence of categorial noise in the client tasks lead to misleading rankings of features and wrong predictions happen due to bias in feature importance. The attack recovery ratio of TA is found to be very low, i.e., 40 percent due to attack evasion risk and reduced trust. The attack recovery ratio of A-GNN is found to be low, i.e., 30 percent as weak large-network deployment and increased latency. The attack recovery ratio of XNFT is low i.e., 45 percent due to slow processing and Poor generalization.

4.

PM4: Bandwidth Utilization (BU(QKD, CCS))

A graph of number of virtual machines versus bandwidth utilization is shown in Figure 6. Bandwidth utilization is high, i.e., 95 percent for QKD with the increase in the number of virtual machines as it can effectively handle complex structure in client tasks using superposition and entanglement operations of quantum computing. The bandwidth utilization of FDL is found to be moderate, i.e., 40 percent as it suffers from poor synchronization due to communication delays. The bandwidth utilization of CS-BL is found to be above average, i.e., 60 percent due to poor local exploitation capability and often struggle to arrive at promising solutions. The bandwidth utilization of RF is found to be very low i.e., 40 percent as frequent update of models increases communication overhead, and high data transfer happens between the large number of trees. The bandwidth utilization of TA is moderate, i.e., 50 percent due to large memory consumption by the transformers in query matrices and key matrices. The bandwidth utilization of A-GNN is lower, i.e., 45 percent as it consumes large memory to store node embeddings, edge embeddings, and adversarial perturbations. The bandwidth utilization of XNFT is lower, i.e., 45 percent as the Memory usage becomes very high for long flow sequences.

5.

PM5: Response time (RT(QKD, CCS))

A graph of number of virtual machines versus response time is shown in Figure 7. It is observed from the graph that the response time of QKD is found to be less, i.e., 80 ms with an increase in the number of virtual machines as the quantum student models are computationally lighter through distillation and require very few quantum operations to reduce response time by 80 percent. The response time of FDL is found to be moderate, i.e., 200 ms as it involves excessive communication overhead during model updates across distributed agents. The response time of CS-BL is found to be high, i.e., 250 ms as the randomness of Levy flight operation takes large number of iterations to arrive at global optimal solution. The response time of RF is found to be very high, i.e., 210 ms as random forest follows ensemble structure and every tree must be trained and traversed for new predictions which leads to linear increase in response time as the tree size increases. The response time of TA is high, i.e., 200 ms as self-attention mechanism has quadratic complexity. The response time of A-GNN is also high, i.e., 240 ms as constant graph updating will be there due to changes in network traffic. The response time of XNFT is high due to additional overhead caused by explained modules such as attention visualization and LIME/SHAP integration.

Overall, the performance of the QKD is good in the detection of DDoS attacks that are flooding based. The performance of the QKD depends on the diversity of the traffic dataset, feature representation capability, and flexible architecture of quantum teacher and student model. The QKD can perform application layer feature learning, temporal behavior modeling, hybrid feature extraction, capturing the protocol aware features and many more. These capabilities of QKD make it efficient in detection of DDoS attacks considering different attack scenarios like botnet, slower is multi-vector DDoS, and protocol exploitation.

The ablation study aims to evaluate contribution of each component of QKD framework that affects key DDoS attack detection. The summary table of the ablation study is given in

Table 3. Ablation study of components of the QKD framework in DDoS attack detection.

Model Component	PLR(QKD, CCS)	ADT(QKD, CCS)	ARR(QKD, CCS)	BU(QKD, CCS)	RT(QKD, CCS)
CNN only	1.9	68	88.2	89.4	95
LSTM only	1.6	61	90.5	91.2	84
CNN-LSTM	0.9	44	94.6	95.3	63
Quantum only	2.5	87	82.4	85.1	120
CNN + Quantum	0.7	39	95.8	96.4	58
CNN-LSTM + Quantum	0.4	30	98.1	98.0	50

.

7. Conclusions

The paper presents a novel quantum enriched with the knowledge distillation framework for the early detection of a DDoS attack in cloud computing. The main contribution of the work is to make use of the parameterized quantum circuit as the teacher model which can capture complex network traffic patterns. The classical machine learning model often fails to capture those patterns. High rate of DDoS attack detection is maintained is achieved by transferring the knowledge from teacher model to student model through distillation process. It is optimal for real-time deployment as it reduces the response time and effectively utilizes the bandwidth through faster prediction and compact size of student model. However, the training of quantum teacher model is computationally expensive as optimization is difficult because of vanishing gradient problem. During the distillation process, there might be chances of loss in quantum information. All classical data need to be converted into quantum states which adds the preprocessing overhead. For future work a deeper form of quantum neural network and variational quantum circuits will be designed to minimize the quantum noise. The distillation process will be further optimized through adaptive temperature tuning for multiple teacher distillation. The knowledge transfer will be carried out layer wise to prevent the performance loss during distillation and enhance the student model accuracy in attack detection. Also, the validation of the QKD framework will be carried out considering real quantum hardware setup, larger qubit configurations, and deeper form of entanglement architectures which make suitable for real-time cloud environments.