The SubBytes operation in the Advanced Encryption Standard (AES) is a critical step performed over the extended field GF(28), defined using the irreducible polynomial p(x) = x8+x4+x3+x+1. However, its implementation using Look-Up Tables (LUTs) on Field Programmable Gate Arrays (FPGAs) is computationally intensive and resource-consuming. This poses a significant challenge for resource-constrained IoT devices, where efficient hardware utilization is critical. Previous studies have explored composite field arithmetic GF((24)2) to reduce complexity by mapping 8-bit elements from GF(28) to GF((24)2). Although these approaches reduce resource usage compared to traditional methods, they primarily rely on polynomial basis (PB)-based arithmetic, which still requires significant LUT resources. To address this limitation, this study proposes an advanced solution by optimizing inverse operations using polynomial ring representation (PRR) in the composite field. By decomposing 8-bit operations into 4-bit computations and leveraging PRR, the method significantly reduces LUT consumption while maintaining AES security and encryption throughput. Experimental validation on an FPGA demonstrates its feasibility for resource-constrained IoT applications, offering a practical and efficient approach to hardware-accelerated AES encryption.

Random number generators (RNGs) are crucial in applications requiring unpredictable sequences, including cryptography, simulations, and gaming. Among the different types of RNGs, ring oscillator (RO)-based RNGs have gained popularity due to their simplicity, and suitability for FPGA implementation. Previous research by Wold et al. has suggested that connecting directly a D flip-flop (D-FF) to the RO circuit enhances randomness. However, the precise factors contributing to the improved randomness through the connection of the D-FF remain unclear. Then, we hypothesize that the D-FF acts as a synchronization circuit, enhances randomness. To verify this hypothesis, we design and implement RO-based RNG circuits with and without a D-FF directly connected to the RO circuit on an FPGA platform. By analyzing and comparing the bit distribution of the generated number sequences, we investigate the impact of the D-FF on the stability of the generated numbers. The results confirm that incorporating a D-FF into the RO-based RNG circuit stabilizes the random number sequence, leading to the conclusion that the D-FF plays a synchronization role in these circuits.

Software-defined networks (SDN) have become prominent technologies in recent times owing to their centralized network management, flexibility, and rapidity. The centralized structure of SDN architecture may introduce vulnerability and threat, which can affect normal users through resource depletion, decreased internet speeds, and memory consumption on controllers and switches. An efficient intrusion detection system (IDS) is required for actively monitoring and identifying malicious activities or potential threats within SDN networks. The current machine learning techniques in IDS often face challenges when dealing with imbalanced datasets. These datasets can lead to biased model performance toward the dominant class, causing inadequate detection of minority-class instances like anomalies or intrusions. Moreover, a large number of features in the dataset increases computational challenges and may adversely affect the model's performance. This work presents a deep learning-based technique generative adversarial networks (GAN) to generate synthetic data for balancing the imbalanced dataset issues in IDS. This helps in improving detection performance, especially for minority classes. The chi-square test based on statistics is also used to select the most significant features that enhance model performance and decrease both training and testing time. We evaluate the model's performance using multiple machine learning algorithms, including Naive Bayes (NB), Extra Trees (ET), Random Forest (RF), and XGBoost (XGB). Our evaluation demonstrates improved accuracy and reduced training and testing times across these algorithms. Notably, XGB achieves the highest accuracy$\mathbf{0. 9 9}$.