Secure and Efficient Block Cipher Mode Design for Parallel Processing and Reliable Security

Abstract

Communication is defined as the process of transferring data and exchanging information between interconnected systems. Due to the increasing reliance on digital infrastructures by the military, financial, and healthcare sectors, it is important to ensure the confidential, authentication, and tamper-proof nature of communications. In addition, the increasing need for secure communications in the fields of network security and cryptography have led to the development of numerous systems. The basic requirement of these systems is that under the same key, identical plaintexts do not result in identical ciphertexts. The most significant contribution to this requirement has came from block cipher modes. There are many traditional modes of operation such as the Electronic Code Book (ECB) compromises between simplicity and security. Probabilistic Modes such as the Cipher Block Chaining Mode (CBC) provide a method to randomize data so that the potential for pattern analysis is eliminated, while Deterministic Modes such as ECB enable potential access to the patterns within the plaintexts. Conversely, since the randomization is in the Probabilistic Mode, there is no access to the patterns; however, the sequentiality of the blocks creates dependence and increases the computing overhead. To address these issues, a novel block cipher mode that provides the highest level of security and the most effective method for performing encryption and decryption will be proposed in this paper. It is anticipated that the improved security features and efficient encryption and decryption procedures will significantly improve confidentiality. The methods proposed will utilize compact key structures, parallel processing, a header generation based on multiple random values, and a Key-derived S Box. The experimental results show that SEBCM is more effective than CBC with respect to speed in both encryption and decryption.

1. Introduction

Data communication in terms of data transmission and reception is an essential area of computing. It involves data exchange, resource sharing, system integration, remote connection, etc. Superfast computing facilities are required because of the rapid growth in information exchange in the current era of digitalization [1]. In all the above, data has been the significant part that is exchanged in different forms. As a result, data security emerges as an important task, as it involves safeguarding the data in terms of transmitted and received messages. This typically keeps the data secure from unauthorized access, manipulations, interceptions, etc. Hence, for reliable communication, the data has to be accurate and consistent during the exchange [2].

Whenever two entities communicate with each other, confidentiality, authentication, and integrity are significant. The area of cryptography and network security address these requirements. Cryptography protects data during transmission by providing encryption and decryption methods that keep communication private. This ensures that the message stays confidential between the sender and the receiver [3]. Most secure computing facilities implement encryption guidelines in the system to ensure confidentiality. Cryptography is classified into two categories: symmetric key cryptography and asymmetric key cryptography. Symmetric key cryptography uses the same key to encrypt and decrypt data [4]. Symmetric cryptographic algorithms like Data Encryption Standard (DES), Advanced Encryption Standard (AES), and Blowfish are widely used. However, using them alone does not guarantee maximum security. To enhance the maximum security of symmetric cryptographic algorithms, they are often combined with block cipher modes of operation. The purpose of using the block cipher modes is to prevent pattern-revealing attacks and introduce randomness into the ciphertext [5]. The block cipher modes divide the plaintext into various equal size blocks, and each block is encrypted separately [3]. There are different levels of security for each block cipher mode; it is important to pick the right one for the job. The CBC and PCBC modes are more secure, but they take up more processing power. The ECB mode is simpler and less secure [6].

Depending on how block cipher modes manage the encryption and decryption process, block cipher modes can be either probabilistic or deterministic [7]. The deterministic block cipher mode uses the same key and algorithm to encrypt the plaintext blocks, which means that the ciphertext block stays the same, while the attacker can quickly find repeated plaintext blocks by comparing ciphertext blocks. Therefore, deterministic modes are more prone to attack and provide a lower security level than probabilistic modes [8]. The use of probabilistic block cipher modes makes the ciphertext random and creates different ciphertext blocks for the identical plaintext blocks. Probabilistic modes have sufficient security to eliminate the possibility of the attacker seeing repeated patterns within the plaintext [8,9].

Today’s digital world requires encryption methods that are both secure and fast. In addition, modern apps like real-time video conferencing, online banking, and healthcare data exchange need confidentiality and authentication, but they also need to be fast and flexible [4,10]. These restrictions become even more important as embedded systems, IoT networks, and mobile devices proliferate [11].

As more Parallel Architectures become common such as Multi-Core CPUs, GPU’s, and FPGA’s; Researchers are working to develop or amend Cryptographic Methods for Parallel Operating Systems. The literature has clearly shown that it is possible to utilize Parallel Architectures to enhance Encryption Speed [12,13,14]. Recent studies conducted by Lee et al. indicated that AES-CTR performance can be accelerated on CUDA platforms via GPU’s by 60–80% [15].

Table 1. Comparison of standard block cipher modes.

Mode	Parallel Enc/Dec	Security	Error Prop	Application
ECB	Yes/Yes	Low	None	Legacy, rarely used
CBC	No/Yes	High	High	File encryption
PCBC	No/No	High	High	Kerberos(v4) authentication
CFB	No/Yes	Medium	Medium	Legacy stream-like use
OFB	No/No	Medium	None	Low-power devices
CTR	Yes/Yes	Medium	None	Streaming, network traffic
XTS	Yes/Yes	Medium	Medium	Full-disk encryption

illustrates the different types of popular block cipher modes and emphasizes the need for more efficient cipher modes.

The Kerberos protocol(V4) uses the PCBC mode for the authentication of messages [16]. According to the IEEE 1619 standard, full-disk encryption, particularly for disc storage devices, frequently uses the XTS mode [17]. Counter (CTR) mode, on the other hand, is a good option for implementations with multiple cores or GPUs because it enables full parallel encryption and decryption. Counter (CTR) mode is better suited for multi-core and GPU implementations than CBC because it allows full parallel encryption and decryption. Galois/Counter Mode (GCM), approved by NIST in 2007, combines counter mode encryption with a polynomial hash for authentication, making it fast and efficient for modern processors [18,19]. Further, consider the flaws in deterministic encryption, paying special attention to its encryption formula given here.

C: Ciphertext Block, E: Encryption Algorithm, K: Key, P: Plaintext Block.

$$C=E(K,P)$$

(1)

For Deterministic Modes

$$C_1=E(K,P) \mathrm{and} C_2=E(K,P)\to C_1=C_2$$

(2)

For Probabilistic Modes

$$C_1=E(K,P,R_1) \mathrm{and} C_2=E(K,P,R_2)\to C_1\ne C_2$$

(3)

It is evident from Equation (1) that the same ciphertext is produced under the same key and plaintext. This deterministic quality shows the attackers patterns and blocks occur redundantly. Because of this, attackers may be able to see patterns in the encrypted data, which could compromise confidentiality. To lower this risk, probabilistic encryption adds randomness so that the same plaintexts encrypted with the same key produce different ciphertexts. This makes the data more secure [20]. $R_1$ and $R_2$ are random numbers that are made up at the time of encryption. The probabilistic nature greatly enhances the system’s security against pattern-revealing attacks [21,22].

According to

Table 2. RSA decryption time with various key sizes.

File Size (MB)	Algorithm/Key Size
	RSA 1024	RSA 2048	RSA 4096
1	2082	3327	9687
3	6047	9833	27,280
5	9895	16,606	45,031
10	19,666	33,001	89,784
25	49,109	82,308	227,277
50	94,490	164,325	466,819
100	186,939	338,471	921,712
Average	368,228	647,871	1,787,590

, RSA decryption time increases sharply as key size increases, especially for larger file sizes. The decryption time of RSA increases significantly with the increase in key size, leading to performance limitations on constrained platforms [11]. While longer keys do improve security by making cryptographic brute-force attacks more difficult [23]. It is well-established that larger key sizes significantly enhance cryptographic strength by making brute-force attacks impractical and providing better resistance against factoring-based attacks [24].

Larger key sizes improve security but introduce impractical computational overhead. Therefore, the central challenge and goal of this work is to design a block cipher mode that delivers strong security even with a smaller key size [25]. Therefore, the challenge is to design a new block cipher mode that supports concurrent (parallel) processing, introduces inherent randomness, offers resilience against various attacks, and provides high security even with smaller key sizes.

This paper introduces Secure and Efficient Block Cipher Mode (SEBCM), which aims to connect the strong security found in theory with the practical needs of real-world use. SEBCM guarantees high-speed, safe communication over a wide spectrum of applications by including header randomization, tailored key-based transformations, and parallel-friendly design. As technology gets better, these kinds of flexible, lightweight, and safe block cipher methods are likely to become the new standard for cryptographic infrastructure in both high-performance and low-performance computing settings.

2. Related Work

Modern cryptography is one of the main mechanisms that enable secure communications. It keeps data safe even in an insecure environment. There are three main types of cryptographic algorithms: symmetric key cryptography, asymmetric key cryptography, and hash-based methods (Figure 1). The sender and receiver use a single shared key in symmetric (secret-key) cryptography to encrypt and decrypt data. Asymmetric cryptography uses a public/private key pair, where data encrypted with one key can only be decrypted with the other. Hash-based cryptography produces a fixed-length hash value from a plaintext, which is one-way that is computationally infeasible to invert [26]. There are two types of symmetric key cryptography: block ciphers and stream ciphers. Block ciphers work with blocks of bits that are always the same size, while stream ciphers work with data as a continuous stream, either bit by bit or byte by byte. There are two types of stream ciphers: synchronous, where the keystream is generated independently of the plaintext, and self-synchronizing, where the keystream is derived from previous ciphertext bits [10]. In general, stream ciphers can handle more data at once, but they are more likely to be attacked in certain ways than block ciphers. In real-world situations like TLS, Bluetooth, 4G, and so on, stream ciphers are faster but are also more vulnerable to cryptanalytic attacks  [27].

2.1. Standard Block Cipher Modes

The National Institute of Standards and Technology (NIST) has set out a number of standard modes, each of which offers different security services, such as authentication, confidentiality, or both [6]. Block cipher modes tell the computer how to encrypt each block of plaintext and how to connect the blocks to each other. In total, there are around 14 standardized block cipher modes that are broadly grouped into three categories: (1) Confidentiality-only modes, e.g., Electronic Codebook (ECB), Cipher Block Chaining (CBC), Cipher Feedback (CFB), Output Feedback (OFB), Counter (CTR), as well as more specialized modes like XTS (disk encryption) and format-preserving encryption modes FF1/FF3. (2) Authentication-only mode—Cipher-based Message Authentication Code (CMAC), the sole standard mode dedicated to message authentication. (3) Authenticated encryption (AE) modes, for example, authenticated encryption (AE) modes combine the processes of keeping data secret and verifying its authenticity in a single step, including methods such as Counter with CBC-MAC (CCM), Galois/Counter Mode (GCM), Key Wrap (KW and its variations KWP, TKW), and Offset Codebook Mode (OCB). Rogaway et al. developed OCB, which was a significant thing since it was a secure technique to encrypt and authenticate data in one pass [28]. It became standard in later versions (OCB2, OCB3). NIST was validated GCM in 2007. It uses a polynomial hash for authentication and counter-mode encryption (the full form of GCM). Its architecture makes it fast and efficient for modern processors [18]. Likewise, CCM (counter mode encryption combined with CBC-MAC), first proposed by Ferguson et al., was designed for efficiency in constrained environments (the Wi-Fi standard 802.11 employs CCM) [29]. Another important mode, XTS, was developed to enhance the security of data storage by incorporating a tweak, which is typically the disk sector number, into the encryption process. This method makes sure that the same plaintext blocks create different ciphertext block for various sectors, which helps keep data safe in block storage systems [4]. Each of these standard modes has certain strengths and weaknesses, and extensive surveys by NIST and others catalog their security properties and limitations. For example, NIST SP 800-38A offers an in-depth review of confidentiality modes (ECB, CBC, CFB, OFB, and CTR), discussing the security features and flaws of each [6].

2.2. Traditional Modes

The balance of performance versus security is a recurring issue with most classic modes. For example, with a mode like CBC (Cipher Block Chaining), PCBC (Propagating Cipher Block Chaining), CFB (Cipher Feedback), and OFB (Output Feedback), each block’s encryption is dependent on the previous block; this serializes the mode and therefore prohibits parallel processing when encrypting/decrypting message blocks [30]. Therefore, CBC will always be about three times slower than CTR (Counter Mode) due to using the last ciphertext block as input to the next block, which prevents parallel processing from occurring. CBC mode’s slower performance makes CTR mode the best choice for many applications because it balances both speed and security. CFB mode turns a block cipher into a self-synchronizing stream cipher. This is possible using the block cipher for both encryption and decryption to save space in the code [31]. For example, CBC is widely used and works with probabilities, but it cannot encrypt blocks at the same time, so it is slower. The performance test shows that CTR is the best choice for many applications because it balances speed and security. CBC, on the other hand, is about three times slower because it relies on the previous ciphertext block, which stops parallel processing.

2.3. Parallelization and High Performance

To address the slowdowns of traditional methods, researchers have suggested new ways and techniques that allow parallel encryption, as well as parallel versions of existing ciphers. Youssef and Tavares proposed a new mode of operation with a novel chaining method that removes sequential dependencies, enabling secure parallel encryption [30]. Park and Van Oorschot proposed the All-or-Nothing Transform (AONT), a pre-processing technique employed prior to encryption to enhance security, despite increasing computational workload [32]. In addition to adding new modes, a lot of work is being done to make encryption algorithms run in parallel at the implementation level. Durad et al. uses MPI to speed up the NIST-standard AES encryption and decryption by running it on computer systems with distributed memory in parallel, making it much faster [12]. Zhang et al. achieved similar performance gains using graphics processing units (GPUs) with CUDA to run AES in parallel, far outperforming a serial AES implementation [13]. Lee et al. built on these findings by improving AES-CTR and AES-ECB on GPUs, reducing some extra work (like recalculating round keys) and increasing speed by up to 63% [15]. Li and Zhang also showed that using GPUs to run block ciphers in parallel can make encryption much faster than the regular method, and it is better at resisting certain side-channel attacks because of how GPUs are built [33]. Bernstein et al. created the eBACS benchmarking platform, which offers a consistent setting and measurements for assessing how fast cryptographic methods work and how much time and memory they use [34]. The implementation of hardware to accelerate AES encryption illustrates how hardware acceleration can deliver results very quickly. In this regard, the work of Homsirikamol et al. illustrates how FPGAs were able to provide significant performance improvements for both whole-block and message-based AES encryption over the same encryption modes as their respective software implementations [35]. The findings also support the potential for accelerated hardware encryption algorithms to effectively address real-time encryption challenges, whether they be in whole-block or message-based formats. Sahi et al. suggested a Parallel Block Cipher (PBC) mode that gets rid of inter-block dependency [36].

2.4. Authenticated Encryption and Novel Modes

In addition to basic confidentiality, modern applications often need authenticated encryption (AE) to make sure that data is both private and safe. Encryption and authentication (for example, encrypt with CBC and then authenticate with CBC-MAC) are used in traditional methods. But newer single-pass modes can do both at once. Guenther et al. created ACORN, a lightweight authenticated encryption algorithm (AEAD) that only needs one key to encrypt and verify messages [37]. ACORN makes it easier to manage keys by using the same key for two things. It also offers security that is similar to other AE schemes. Song et al. reviews block cipher modes and their challenges in modern computing environments [38]. Morgari et al. created Zorro, a fast and flexible block cipher mode that aims to solve practical problems like the need for plaintext padding and the fact that some modes are hard to run in parallel [22]. Zorro avoids padding overhead and permits parallel processing, resulting in improved encryption/decryption speeds over classical modes. Similarly, ciphertext stealing (CTS), proposed by Rogaway et al., is capable of encrypting non-aligned plaintext, as it also avoids padding [39]. For instance, Markowitch and Nakahara examined how an attacker can manipulate specific bits of plaintext or ciphertext to distinguish between different modes or even decrypt data referred as bit-flip attacks [40].

2.5. Chaos-Based and Specialized Encryption Techniques

Neural networks, chaos theory, and other unconventional methods are used in a parallel line of research to design cryptography. For batched image data, Zhou et al. [41] developed a parallel encryption algorithm based on chaos. By exploiting chaotic maps and multi-core processors, this method encrypts large image sets efficiently in parallel, yielding improved performance and security. Noura et al. [42] proposed an efficient chaotic encryption scheme (operating in OFB mode) that achieves high speed and strength by using fewer rounds and a variable S-box construction. Their cipher is resistant to differential, linear, statistical, and brute-force attacks. It also does better than algorithms like DES, 3DES, and even AES in some ways. However, its effective key space is smaller than that of standard AES, which is a known trade-off. This paper discusses the chaotic OFB-mode cipher and stresses that chaotic methods can provide high security at a low cost. Another approach to parallel encryption was presented by Zhang et al. [13] who explored GPU-based acceleration of the AES algorithm using CUDA. Their implementation processes independent AES blocks in parallel, achieving substantially higher encryption throughput than conventional serial CPU-based approaches. Dhall et al. [43] proposed a probabilistic block cipher for image encryption that utilizes random bits to increase the ciphertext size, thereby incorporating additional randomness into the output. This probabilistic encryption makes it much harder to break the code, but it also makes the ciphertext bigger. This is an acceptable trade-off in situations like image storage where security is very important. These bio-inspired and chaos-based approaches demonstrate the creativity inherent in cryptographic research for niche domains such as secure multimedia encryption. Experiments also indicate that they can effectively defend against statistical and correlation attacks. Kimura et al. [44] introduced a neural-network-based evaluation tool for assessing the pseudo-randomness of stream cipher outputs, highlighting the effectiveness of learning-based techniques in cryptographic analysis.

2.6. Lightweight Cryptography and IoT

As computing moves to IoT devices, sensors, and wearables, encryption schemes that use less memory, power and computing are in demand. Many traditional modes and ciphers are not practical on devices with limited resources to handle large keys, long initialization vectors, and heavy computations. Performance frameworks like FELICS-AEAD allow consistent benchmarking of AEAD schemes in IoT contexts [45]. Gulen et al. discuss these limitations in the context of wireless sensor nodes [46]. To address this, researchers have developed modes optimized for low-resource environments. Butin et al. introduced TinyCrypt, a lightweight cryptography library tailored for IoT platforms [47]. TinyCrypt provides effective implementation of widely utilized algorithms for devices in low-energy environments requiring low power consumption (e.g., medical sensors, smart meters and wearables) and deploying techniques for side-channel attack prevention. In addition to TinyCrypt, Cui and Katz suggested developing Spix, a stateless AEAD Mode of operation designed especially for IoT devices that may not maintain state between sessions [48]. Spix does away with persistent counts or unique peculiarities for each message. This lowers the danger of nonce reuse or mishandling and makes it easier to deploy on hardware with limited resources. Kaps [49] created ChaiTEA, a lightweight block cipher based on the TEA algorithm, for wireless sensor networks. It changes the cipher and mode of operation to function well with limited memory and power. ChaiTEA strikes a great balance between security and resource use in sensor network contexts by reducing key scheduling and using shorter block lengths.

2.7. Security Against Misuse and Attacks

A nonce or initialization vector (IV) is a public, non-secret value used to introduce randomness into probabilistic encryption schemes. In block cipher modes such as CTR and GCM, the nonce/IV must be unique for each encryption under the same secret key. This uniqueness requirement is essential to prevent leakage of relationships between ciphertext blocks and to preserve confidentiality [50].

Nonce/IV management is therefore a critical aspect of secure system design. Modes such as CTR and GCM require a fresh nonce for each encryption instance; if a nonce is reused, either accidentally or adversarially, confidentiality can be completely compromised. Song et al. identify this risk in their analysis of block cipher modes and note that even high-performance implementations remain vulnerable when nonce generation or synchronization is unreliable [38]. Ensuring correct nonce/IV generation is particularly challenging in distributed, high-throughput, or parallel environments.

To mitigate such risks, Bellare and Tackmann propose robust authenticated encryption (AEAD) constructions that remain secure even when nonces repeat. Their approach allows nonce reuse without catastrophic failure by introducing internal randomness and carefully composing cryptographic primitives [51]. Similarly, Rogaway et al. introduced Synthetic Initialization Vector (SIV) modes, which provide deterministic authenticated encryption without requiring a fresh IV for each encryption instance [28]. In SIV-based constructions, identical plaintexts encrypt to identical ciphertexts under the same key only when no additional randomness is supplied. Security against chosen-plaintext and chosen-ciphertext attacks is achieved because the synthetic IV is derived as a pseudorandom function of the plaintext and associated data, causing any ciphertext modification or forgery to be detected during decryption [28].

More generally, Bellare and Rogaway argue that symmetric encryption schemes should be designed to tolerate certain classes of misuse and to fail gracefully rather than catastrophically under imperfect operating conditions [28]. In this work, we adopt these principles by designing SEBCM to maintain confidentiality under nonce misuse scenarios while preserving parallelizability. Integrity protection is intentionally left outside the scope of this mode and can be achieved by combining SEBCM with a standard message authentication mechanism.

2.8. Post-Quantum and Future Threats

Modern cryptography must also consider emerging threats, notably the advent of quantum computing. In general, symmetric-key cryptographic algorithms are considered more resilient to known quantum attacks than asymmetric algorithms, provided sufficiently large key sizes are used [52]. In particular, Grover’s algorithm offers at most a quadratic speedup for brute-force attacks, effectively reducing the security of an n-bit symmetric key to approximately n/2 bits, whereas widely deployed public-key schemes can be completely broken by Shor’s algorithm on a sufficiently powerful quantum computer  [53,54,55]. Researchers are working on quantum-safe modes that keep efficiency while adding more security. Hosoyamada et al. [56] suggest the first provably secure construction of tweakable block ciphers that can withstand quantum superposition attacks using a basic mode termed LRWQ, built from quantum-safe block ciphers and proven secure. Another improvement in Tweakable Enciphering Scheme with Tweak (TET), which offers strong security in settings with few resources [57,58]. TET enhances a block cipher’s security by utilizing tweaks, which are public, non-secret inputs that diversify the encryption transformation for each invocation. Unlike an initialization vector that randomizes encryption probabilistically, a tweak deterministically modifies the block cipher’s permutation, ensuring that identical plaintext blocks encrypt differently across distinct contexts without increasing key management complexity. Farfalle is a permutation-based cryptographic construction proposed by Bertoni et al. [59] that enables the design of pseudorandom functions and authenticated encryption schemes with inherent parallelism. By relying on a single underlying permutation and domain separation, Farfalle supports high-throughput and hardware-friendly implementations, making it suitable for modern cryptographic applications requiring both efficiency and flexibility. Recent work by Ananth, Qian, and Yuen explores constructing pseudorandom quantum states to bolster encryption against quantum adversaries [60].

2.9. Formal Verification and Theoretical Foundations

Formal security analysis has become more important as encryption mechanisms are used in more and more important systems, such as those used in cars and medical devices.

Researchers use tools like ProVerif and CryptoVerif to mathematically show that the suggested modes are secure against several types of attacks, such as the chosen plaintext attack (IND-CPA) and the chosen ciphertext attack (IND-CCA) [61,62]. Blanchet et al. (2013) demonstrated how to use ProVerif to check block cipher modes and make sure that each one protects privacy and integrity even when attackers are trying to crack it [61]. Formal methods are useful in discovering small anomalies that would typically go unnoticed in practical tests and provide a level of assurance to users about the mode’s design. The safety-critical areas include systems like self-driving cars; thus, they depend heavily on the existence of formal security criteria and adversary models to measure new cipher modes.

As far as block cipher mode designs go, there is currently a move away from traditional schemes to adaptive designs that are both parallelizable and lightweight [63]. Current ongoing research focuses on providing enhanced security guarantees while not compromising key size and performance. A new block cipher mode is proposed, based on these insights. The cipher mode proposed in this paper is designed to be secure yet efficient, supporting parallel processing and providing robust protection against both classical attacks (e.g., cryptanalysis and bit-flips). Our approach offers a good balance for modern secure communication systems. As it addresses the limitations present in prior work, like using very large keys, a lot of randomization, or strict sequential processing [50,64].

Despite the advances in encryption techniques and mode design surveyed above, many real-world cryptographic failures stem from weaknesses in implementation or improper use of these modes. In the next section, some of the most well-known attacks on cipher modes and implementations are discussed.

2.10. Cipher Attacks vs. Block Cipher Modes

The susceptibility of various block cipher modes to common attacks are summarized in

Table 3. Block cipher modes vs. attacks.

Cipher Mode	Bit-Flip	IV Manip.	Replay	Nonce/IV Reuse
CBC	Yes	Yes	Yes	No
PCBC	Yes	Yes	No	No
CFB	Yes	No	Yes	Yes
OFB	Yes	No	Yes	Yes
CTR	Yes	No	Yes	Yes
XTS	Yes	No	Yes	Yes

. As listed in Table 3, different block cipher modes are vulnerable to different types of cryptographic attacks. It covers six cipher modes, namely CBC, PCBC, CFB, OFB, CTR, and XTS. Then, models are subjected to four types of attacks: bit-flip, IV manipulation, replay attacks, and nonce/IV reuse vulnerabilities. A bit-flip attack affects all the modes, which shows that they all have a weakness when it comes to changing plaintext through ciphertext manipulation [65]. IV manipulation can affect CBC and PCBC, but not CFB, OFB, CTR, or XTS. Replay attacks work on all modes except PCBC, which is used in Kerberos authentication. This is because PCBC is serial in both encryption and decryption [66]. Also, CFB, OFB, CTR, and XTS can have problems with nonce/IV reuse. This indicates the need to handle IVs appropriately and utilize them just once for each encryption session [67].

The block cipher modes are classified into two categories based on encryption: Encryption Over Plaintext (Chaining-Based Modes) and Encryption Over IV/Random Number (Stream-Cipher-Like Modes) [68]. The efficacy of any encryption method is fundamentally determined by the computational resources necessary for an adversary to breach the encryption key. Table 2 shows that increasing the key size makes the execution time longer. However, this trade-off makes security much better and makes the system more resistant to brute-force and cryptanalytic attacks. Hence, a longer key size and longer block might be more secure. This happens because handling a 128-bit key on a 64-bit processor requires two 64-bit CPU registers to be used to perform the computations and represent a 128-bit number. Therefore, we propose SEBCM to achieve high security without large keys or heavy randomness overhead and to support parallel processing.

3. Proposed Method: SEBCM

This section describes the proposed Secure and Efficient Block Cipher Mode (SEBCM), covering S-box generation, the encryption process, and the decryption process. Both the S-box generation and the encryption process are explained in detail in the following sub-sections. The proposed method provides greater essential security without a gradual increase in key size.

3.1. Proposed S-Box Generation Method

SHA-512 hashing of the secret key and advanced permutation techniques are used to generate the S-box. This makes it secure, dynamic, and bijective. The generation process takes as input the baseline S-box and the secret key. The complete S-box generation procedure is illustrated in Figure 2.

The S-box generation involves multiple cryptographic operations, like:

• Baseline S-box initialization.
• Hash initialization (SHA-512).
• Generate a nonlinear array (L).
• Permute the S-box using the L array.
• Iterative Transformative Permutation.

3.1.1. Baseline S-Box Initialization

Create the S-Box as a linear array of integers from 0 to 255 to serve as the basis for permutations of the S-Boxes so that you end up with a total of 256 bytes, as described in Algorithm 1.

Algorithm 1 Initialise_S-BOX_Identity

1: Declare array S-BOX [0…255] 2: for i ← 0 to 255 do 3:    S-BOX[i] ← i 4: end for 5: return S-BOX

3.1.2. Hash Initialization (SHA-512)

The secret key will be hashed first using the SHA-512 hash algorithm to create a hashed secret key of 64 bytes (512 bits) that are compatible with all symmetric encryption algorithms regardless of their input sizes. The output of the SHA-512 function will always produce a fixed-size output of 64 bytes (512 bits), no matter what input is provided. Figure 3 shows generation hash value through hashing using SHA-512.

3.1.3. Generation of Nonlinear Array L

To enhance the diffusive and nonlinear properties of encryption, the SHA-512 hash of the secret key is used to generate a nonlinear array L. Since SHA-512 produces a 512-bit output, the hash output consists of 64 bytes. The nonlinear array L is constructed by considering all unique unordered pairs of bytes selected from these 64 bytes, resulting in $\left({\displaystyle \genfrac{}{}{0pt}{}{64}{2}}\right)=2016$ distinct byte pairs. For each byte pair $(b_i,b_j)$, two nonlinear values are generated: one using a bitwise XOR operation and another using modular addition modulo 256. This yields a total of $2\times 2016=4032$ bytes. The complete procedure for constructing the nonlinear array L is presented in Algorithm 2.

Algorithm 2 Nonlinear Array L Generation

1: Initialize an empty list L 2: Set index counter $t\leftarrow 0$ 3: for $i\leftarrow 0$ to 63 do 4:   for $j\leftarrow i+1$ to 63 do 5:     $L\left[t\right]\leftarrow B\left[i\right]\oplus B\left[j\right]$ 6:     $t\leftarrow t+1$ 7:     $L\left[t\right]\leftarrow \left(B\right[i]+B[j\left]\right) \mathrm{mod} 256$ 8:     $t\leftarrow t+1$ 9:   end for 10: end for

$B\left[i\right]$ and $B\left[j\right]$ represent the ith and jth bytes of the hashed key, respectively. There are 2016 distinct byte pairings from 64 elements. For each pair, two values are calculated: one using XOR and the other using modular addition. The final array L has 4032 bytes in total as a result. This nonlinear transformation greatly improves the cryptographic strength by making the internal state of the cipher more random and unpredictable.

3.1.4. Permute S-Box Using L Array

To introduce additional diffusion and key dependence into the S-box, the generated L array is utilized to perform a series of swap operations on a predefined baseline S-box. The L array, consisting of 4032 bytes, is processed into consecutive pairs, yielding 2016 index pairs, as described in Algorithm 3.

Algorithm 3 Permute S-box using L array

1: for $i\leftarrow$ 0 to 4030 with step size 2 do 2:   Let $x\leftarrow L\left[i\right]$ 3:   Let $y\leftarrow L[i+1]$ 4:   Swap(S-BOX[x] and S-BOX[y]) 5: end for

This method performs 2016 swaps to the S-box, each of which is based on values from the key-dependent L array. Because of this, even little changes to the secret key will cause the S-box to be rearranged entirely.

3.1.5. Iterative Transformative Permutation

The purpose of function is to improve the non-linearity and diffusion features of the created S-box by repeatedly applying a set of byte-level transformations. It utilizes the L array to guide each stage of the permutation process. This ensures that the final S-box is highly sensitive to even small changes in the input key, thereby increasing cryptographic robustness. The transformation process is illustrated in Figure 4.

Each element in the L array is used to permute the S-box. A total of 4032 transformation iterations are performed to generate the final S-box. In each iteration, a single value from the L array is used, as depicted in Figure 4. The steps for each iteration are as follows:

• Apply the Reversal-Based Hierarchical Permutation function to the S-box.
• XOR every element in the S-box with the current L[i] value.
• Apply the Balanced Interleave Permutation function again.
• Perform modular addition of L[i] to every element of the S-box.
• Perform the Value_Index_Guided_Swap function on the S-box.

The S-box generated will be a permutation of the initial S-box and bijective in nature.

Reversal-Based Hierarchical Permutation

This function performs a hierarchical permutation on a 256-byte S-box by reversing chunks of sizes 2, 4, 8, 16, 32, 64, and 128 bytes sequentially, thereby reordering bytes across multiple scales, as described in Algorithm 4.

Algorithm 4 Reversal-Based Hierarchical Permutation

1: function Reversal_Based_Hierarchical_Permutation(s[256]) 2: chunk_sizes ← [2, 4, 8, 16, 32, 64, 128] 3: for k ← 0 to 6 do 4:    n ← chunk_sizes[k] 5:    for i ← 0 to $(256/n)-1$ do 6:      t ← $i\times n$ 7:      for j ← 0 to $n-1$ do 8:         temp[j] ← $s[t+n-1-j]$ 9:      end for 10:      for j ← 0 to $n-1$ do 11:         $s[t+j]$ ← temp[j] 12:      end for 13:    end for 14: end for 15: return s

Balanced Interleave Permutation

The Balanced Interleave Permutation function performs a simple interleaving operation on a 256-byte S-box by alternately combining elements from its first and second halves, as described in Algorithm 5.

Algorithm 5 Balanced Interleave Permutation

1: function Balanced_Interleave_Permutation(s[256]) 2: $x1$ ← s[0 to 127] 3: $x2$ ← s[128 to 255] 4: y ← empty list 5: for i ← 0 to 127 do 6:    y.append($x1\left[i\right]$) 7:    y.append($x2\left[i\right]$) 8: end for 9: return y

The Value_Index_Guided_Swap function performs a nonlinear, data-driven permutation on a 256-byte S-box by using the values at consecutive positions as indices for swap operations. This transformation introduces additional nonlinearity into the S-box and modifies its internal state, as described in Algorithm 6.

Algorithm 6 Value Index Guided Swap

1: function Value_Index_Guided_Swap(s[256]) 2: for i ← 0 to 254 step 2 do 3:    x ← $s\left[i\right]$ 4:    y ← $s[i+1]$ 5:    temp ← $s\left[x\right]$ 6:    $s\left[x\right]$ ← $s\left[y\right]$ 7:    $s\left[y\right]$ ← temp 8: end for 9: return s

Similar to prior dynamic substitution box designs using permutation-based schemes [69], SEBCM employs a key-derived S-box that reacts sensitively to input changes. For security, the S-box generation steps are inherently sequential (non-parallelizable). This makes it significantly harder for an attacker to parallelize the key search by splitting the S-box calculation, which makes the system more resistant to brute-force attacks. For better insight, each operation and its security contribution are listed in

Table 4. S-box operations and their security contribution.

Function Name	Security Contribution
SHA–512 function	Ensures high unpredictability and key sensitivity
Generate a nonlinear array (L)	Introduces nonlinearity and enhances diffusion
Permute S-box using array (L)	Provides key-dependent diffusion and obfuscation
Reversal-Based Hierarchical Permutation	Enhances confusion and resists structural attacks
Balanced Interleave Permutation	Disrupts spatial correlations and enhances mixing
Value index-guided swap	Introduces data-dependent transformation, increasing non-linearity
Apply the final permutation	Amplifies avalanche effect and rounds-based complexity

.

In short, changing even one bit of the input key will change the S-box entirely. Due to hashing, swapping and permutations, the key is extremely sensitive and nonlinear, two characteristics that are crucial for secure encryption.

3.2. Encryption Process

In the encryption process the plaintext is divided into fixed-sized blocks depending on the symmetric encryption algorithm. Initially, the three random numbers (R1, R2, and R3) are randomly generated. The random numbers are first encrypted to form the header. Then, each plaintext block D[i] is encrypted using the key, the index number of the block and random numbers. The encryption process for symmetric cryptography is illustrated in Figure 5.

3.2.1. Header Generation

The header contains three blocks. They are the result of encrypting the three random numbers (R1, R2, and R3). Each random value $R_j$ is first encrypted using the encryption algorithm with key K, and then the value is substituted byte-by-byte using the key-dependent S-box. Figure 6 shows the header generation process.

Each encryption session uses three random values ($R_1$, $R_2$, and $R_3$), which will serve a role similar to nonces or IVs in other modes. These values should be unique for each encryption instance. This means that each encryption instance will have a unique header. Header blocks ($H_1$, $H_2$, and $H_3$) are generated using:

$$H_j=\mathrm{S}\text{-}\mathrm{box}\left[\mathrm{Encrypt}\left(R_j\right)\right], \mathrm{where} j\in \{1,2,3\}$$

(4)

3.2.2. Encryption of Data

The encryption process converts plaintext blocks into ciphertext blocks, denoted clearly by indexing. Let D[i] represent the i-th plaintext block. Every plaintext block D[i] is encrypted to produce its corresponding ciphertext block E[i] in parallel. The encryption equation is defined as:

$$E\left[i\right]=\mathrm{Encryption}(T_i\oplus D\left[i\right],K)$$

(5)

Here, $T_i$ is a transformation value computed by the function F as follows:

$$T_i=F(R_1,R_2,R_3,i)=\left(R_1+\left(R_2\oplus (R_3+i)\right)\right) \mathrm{mod} 2^N.$$

(6)

The function F produces a pseudo-random mask $T_i$ for each block, ensuring that each plaintext block is XOR-ed with a distinct value prior to encryption. In Equation (6), N denotes the block size in bits and K represents the symmetric encryption key. This transformation introduces randomness into the ciphertext, thereby preventing pattern-based attacks. Figure 7 illustrates the computation of the transformation value $T_i$.

The overall ciphertext structure, including header blocks, is represented as:

$$C=\{H_1,H_2,H_3,E_1,E_2,E_3,\dots ,E_n\}$$

(7)

The encryption process allows parallel block encryption, unlike CBC mode, and operates directly on the plaintext blocks, enhancing computational efficiency. Figure 8 illustrates the encryption workflow clearly.

The encryption design supports thread-level parallelism. On multi-core CPUs or GPUs, independent threads can encrypt various blocks concurrently. Every thread can be in charge of one plaintext block to maximize GPU or FPGA implementation. The key-derived S-box and random numbers are broadcast to all threads once, avoiding redundancy and reducing memory usage. If the transformation value ($T_i$) can be pre-computed before encryption and stored as an array, it will decrease the computation time.

3.3. Decryption Process

The decryption process is the exact inverse of the encryption process. The decryption process involves the following steps:

1.

Construct the S-box using the secret key.

2.

Construct the inverse S-box.

3.

Decrypt the header blocks (H1, H2, H3).

4.

Compute the transformation values $T_i=F(R_1,R_2,R_3,i)$ for each data block index i.

5.

Decrypt each ciphertext block $E_i$ using the key, then compute $D_i=\mathrm{Dec}(E_i,K)\oplus T_i$.

The receiver uses the shared key to regenerate the same S-box and then constructs its inverse by mapping each output value back to its original input index, as described in Algorithm 7. To recover the random numbers ($R_1,R_2$, and $R_3$), the header blocks ($H_1,H_2$, and $H_3$) are first substituted using the inverse S-box, followed by the decryption operation.

$$R_j=\mathrm{Decrypt}(\mathrm{Inverse}\text{\_}\mathrm{S}\text{-}\mathrm{box}(H_j)), \mathrm{where} j\in \{1,2,3\}$$

(8)

Algorithm 7 Inverse S-box Construction

1: Generate S-BOX using the shared key 2: for $i \leftarrow 0$ to 255 do 3:    Inverse_S-BOX[S-BOX[i]] ← i 4: end forreturn Inverse_S-BOX

Once the random numbers ($R_1,R_2$, and $R_3$) are recovered, the ciphertext blocks can be decrypted and combined with the transformation value $T_i$ to get the plaintext blocks.

$$D\left[i\right]=\mathrm{Dec}(E\left[i\right],K)\oplus T_i, \mathrm{for} i=1 \mathrm{to} n$$

(9)

The function F used during decryption is identical to the one used during encryption, maintaining consistency in the process:

$$T_i=F(R_1,R_2,R_3,i)=(R_1+(R_2\oplus (R_3+i))) (\mathrm{mod} 2^N)$$

(10)

Using random numbers and the function, the decryption process accurately recreates the plaintext and can be thought of as reversing the encryption process and being able to secure the data for future recovery.

The decryption process is demonstrated in Figure 9. Once the random numbers are retrieved, any ciphertext block will be independently decrypted. This means that the process can be performed on a large number of ciphers in parallel, allowing the decryption process to take place much faster than would be possible without this capability, making it an ideal choice for high-performance applications.

4. Security Model and Analysis of SEBCM

This section formalizes the security objectives of the proposed Secure and Efficient Block Cipher Mode (SEBCM). Rather than making informal claims such as “tamper-proof” or “guaranteed security,” we describe the precise threat model, the adversarial capabilities, and the cryptographic properties targeted by the proposed design.

4.1. Threat Model

We consider a probabilistic polynomial-time (PPT) adversary $\mathcal{A}$ who has full access to the encryption algorithm of SEBCM. The adversary may adaptively query an encryption oracle with plaintexts of its choice and observe the corresponding ciphertexts (chosen-plaintext attack setting).

The adversary is assumed to:

• Observe all ciphertexts and headers transmitted over the channel.
• Attempt to infer information about plaintexts or detect structural patterns.
• Attempt to distinguish encryptions of chosen messages.

The adversary is not assumed to have access to the decryption oracle in the primary security goal. Protection against active attacks such as ciphertext forgery, replay filtering, or message authentication is not the primary focus of this work.

4.2. Primary Security Goal

The main security goal of SEBCM is to achieve confidentiality under chosen-plaintext attacks (IND-CPA-style security) while supporting parallel encryption and decryption.

Informally, this means that an adversary should not be able to distinguish the encryptions of two chosen plaintexts of equal length, even after observing polynomially many encryptions of other plaintexts. This definition follows the standard indistinguishability-based framework used for symmetric encryption schemes in the modern cryptography literature.

4.3. SEBCM Randomization Structure

SEBCM introduces probabilistic behavior using three fresh random values $(R_1,R_2,R_3)$ generated independently for each encryption session. These values serve as the source of randomness for the entire message and are embedded into the ciphertext through the encrypted header blocks $(H_1,H_2,H_3)$.

For each plaintext block $D\left[i\right]$, SEBCM computes a block-specific transformation value:

$$T_i=F(R_1,R_2,R_3,i)$$

and applies masking before block cipher encryption:

$$E\left[i\right]={\mathrm{Enc}}_K(D\left[i\right]\oplus T_i)$$

This construction ensures that:

• Identical plaintext blocks at different positions encrypt differently.
• Identical plaintext blocks in different encryption sessions encrypt differently.
• Each block is independently randomized, enabling parallel processing.

4.4. On the Role of the Transformation Function $T_i$

In SEBCM, the transformation value $T_i$ is derived as a deterministic function of session-level random values $(R_1,R_2,R_3)$ and the block index i. The primary purpose of this construction is to introduce block-level diversification and to prevent deterministic repetition of ciphertext blocks.

It is emphasized that $T_i$ is not claimed to be a cryptographically secure pseudorandom function (PRF) in the formal sense. Instead, it serves as a lightweight masking mechanism designed to eliminate visible plaintext patterns and to enable fully parallel encryption and decryption.

The randomness tests reported in Section 5.1 provide empirical evidence that this mechanism introduces strong practical diffusion and randomness. However, these tests do not constitute a formal indistinguishability proof. A PRF-based derivation of $T_i$ with formal security guarantees is left as future work.

4.5. Intuition for Confidentiality

The confidentiality of SEBCM relies on three main components:

1.

Fresh Random Header: The values $(R_1,R_2,R_3)$ introduce per-session randomness, preventing deterministic encryption.

2.

Per-Block Transformation: The function $F(R_1,R_2,R_3,i)$ ensures that each block is masked with a distinct value, removing structural repetition and enabling independent block processing.

3.

Key-Derived Dynamic S-box: The S-box is generated from the secret key using cryptographic hashing and nonlinear permutations, increasing key sensitivity and resistance to structural analysis.

Under the assumption that the underlying block cipher behaves as a pseudorandom permutation (PRP) and that the transformation values $T_i$ are computationally unpredictable to the adversary, SEBCM aims to achieve IND-CPA-style confidentiality.

4.6. What SEBCM Does Not Claim

SEBCM, as specified, does not provide:

• Ciphertext Integrity (INT-CTXT): SEBCM does not detect or reject modified ciphertexts.
• Authenticated Encryption (AEAD): SEBCM does not include authentication tags.
• Replay Protection: Replay resistance must be implemented at the protocol level.
• Chosen-Ciphertext Security (IND-CCA): The scheme is not claimed to be IND-CCA secure.

4.6.1. Relation to XTS Mode

XTS is a standardized tweakable encryption mode primarily intended for sector-based disk encryption, where the tweak is derived from the sector number. XTS mode can be only used in disk storage applications, whereas SEBCM is intended for session-oriented encryption with randomized headers.

4.6.2. Limitation of Predictable $T_i$

Since the transformation value $T_i$ is implemented as a lightweight masking mechanism rather than a formal pseudorandom function, its security contribution is limited to obfuscation. If an adversary is able to predict or reconstruct the sequence of $T_i$ values, the masking layer can be effectively removed under chosen-plaintext queries, reducing the security of the mode to that of the underlying block cipher. While this does not compromise the security of the block cipher itself, it may eliminate additional mode-level masking benefits and weaken resistance to structural distinguishers. Strengthening $T_i$ using a PRF- or KDF-based construction is therefore identified as a direction for future work.

The design primarily focuses on confidentiality, randomness, and parallelizability. For applications requiring integrity and authenticity, SEBCM can be combined with a standard message authentication code (MAC) using an encrypt-then-MAC paradigm, which is left as future work.

4.6.3. Dependence on Randomness and Nonce Reuse

SEBCM relies on the randomness of the session parameters $(R_1,R_2,R_3)$ to ensure probabilistic encryption and to prevent pattern reuse across messages. As with other randomized encryption modes such as CBC and CTR, the security of SEBCM assumes the availability of a sufficiently strong random or pseudorandom number generator. Reuse of the same $(R_1,R_2,R_3)$ values across different sessions would reduce the effective randomness of the whitening process and may lead to information leakage through repeated whitening patterns. However, this limitation is not unique to SEBCM and reflects a common assumption in nonce-based encryption schemes. The current design therefore assumes proper nonce generation, and analysis of misuse-resistant variants under nonce reuse is identified as future work.

4.7. Error Localization Property

Unlike chaining-based modes such as CBC, SEBCM processes blocks independently. As a result, a modification in a ciphertext block affects only the corresponding plaintext block upon decryption. This property is referred to as error localization.

It is emphasized that error localization does not imply integrity or tamper detection; it merely prevents error propagation across blocks.

4.8. Summary

SEBCM is a probabilistic, parallelizable encryption mode targeting IND-CPA-style confidentiality. Its design combines session-level randomness, block-level masking, and a dynamic key-derived S-box to prevent pattern leakage and enable high-throughput implementations. Formal treatment of integrity and authenticated encryption is left as future work.

5. Results and Discussion

This work focuses on confidentiality-preserving block cipher modes that provide pattern hiding and inherent parallelism. Modern authenticated encryption modes such as GCM, CCM, OCB, and SIV additionally provide integrity and authenticity, which are orthogonal to the design objectives of SEBCM. Therefore, a direct runtime comparison with AEAD modes is outside the scope of the present study and is left for future work.

SEBCM mode provides thread-level parallelism. Each block can be executed in parallel by using threads on a GPU or multi-core CPU. The S-box generation and the transformation values $T_i$ can be pre-computed and stored, further speeding up the encryption if memory permits. Since the key-derived S-box is a deterministic function of the secret key, it can be generated offline at key installation time and reused across multiple encryption sessions, similar to round-key precomputation in standard block ciphers. As a result, the 4032-iteration S-box generation process is not executed per message and does not lie on the online encryption critical path. The online cost of SEBCM therefore consists of a constant header-processing phase followed by fully parallel block encryption.

The execution times reported in

Table 5. Encryption time with various modes and symmetric algorithms.

Algorithm	No. of Blocks	CBC Time (s)	CTR Time (s)	SEBCM Time (s)
AES128	100	0.02	0.02	0.02
	1K	0.17	0.16	0.17
	10K	1.73	1.71	1.78
	100K	16.42	6.61	6.14
	1M	178.3	54.31	54.33
AES192	100	0.02	0.02	0.02
	1K	0.21	1.29	1.22
	10K	2.05	2.1	1.99
	100K	23.00	6.57	6.77
	1M	226.79	55.74	56.77
AES256	100	0.02	0.03	0.02
	1K	0.24	0.26	0.20
	10K	2.34	2.43	2.55
	100K	23.52	8.16	9.84
	1M	260.53	60.03	58.84
DES	100	0.06	0.06	0.07
	1K	0.55	0.54	0.56
	10K	6.55	2.01	3.54
	100K	62.78	8.02	9.57
	1M	598.28	69.77	70.32
TDES	100	0.18	0.17	0.17
	1K	1.70	1.62	1.80
	10K	17.04	3.27	4.82
	100K	164.57	21.38	23.07
	1M	1673.73	205.64	203.56

and

Table 6. Decryption time with various modes and symmetric algorithms.

Algorithm	No. of Blocks	CBC Time (s)	CTR Time (s)	SEBCM Time (s)
AES128	100	0.02	0.03	0.03
	1K	0.23	0.23	0.23
	10K	2.29	2.23	2.28
	100K	5.31	6.42	6.83
	1M	54.83	53.77	57.37
AES192	100	0.03	0.03	0.03
	1K	0.27	0.29	0.29
	10K	2.76	2.79	2.75
	100K	7.17	6.72	7.16
	1M	61.53	59.79	60.68
AES256	100	0.03	0.03	0.03
	1K	0.33	0.33	0.24
	10K	3.42	3.27	3.31
	100K	7.32	8.41	9.52
	1M	70.27	59.14	58.31
DES	100	0.06	0.06	0.06
	1K	0.54	0.54	0.54
	10K	5.26	5.32	5.45
	100K	9.55	7.85	9.72
	1M	81.04	68.47	73.42
TDES	100	0.16	0.17	0.17
	1K	1.69	1.62	1.69
	10K	3.28	3.33	4.84
	100K	20.85	21.20	23.18
	1M	221.81	203.49	206.96

represent full end-to-end measurements and include the complete cost of key-derived S-box generation, header processing, and block encryption. Therefore, the reported results correspond to a conservative cold-start evaluation.

Let $T_{\mathrm{hdr}}$ denote the constant-time header processing cost and $t_{\mathrm{SEBCM}}$ denote the steady-state per-block encryption time after initialization. With a pre-computed S-box, the total runtime for encrypting N blocks can be expressed as

$$T_{\mathrm{SEBCM}}\left(N\right)=T_{\mathrm{hdr}}+N·t_{\mathrm{SEBCM}}.$$

For small messages, the constant initialization overhead dominates, resulting in higher latency compared to traditional modes. For medium-to-large messages or long-lived sessions, this cost is amortized and the benefits of block-level parallelism become evident. This behavior is consistent with the empirical results reported in Table 5 and Table 6.

5.1. Empirical Randomness and Diffusion Analysis

This section presents an empirical evaluation of the statistical randomness and diffusion properties of SEBCM. These tests aim to demonstrate practical pattern hiding and block-level diversification, rather than to provide a formal cryptographic indistinguishability proof.

The primary objective of employing block cipher modes is to prevent pattern-revealing attacks and to introduce sufficient randomness into the resulting ciphertext.

Figure 10 presents a randomness analysis of various block cipher modes applied in image encryption, offering a comparative visualization of their effects on a sample image. The original image is encrypted using the Data Encryption Standard (DES) symmetric encryption algorithm across three distinct modes: Electronic Codebook (ECB), Cipher Block Chaining (CBC), and Secure and Efficient Block Cipher Mode (SEBCM). As shown, ECB mode shows visible patterns from the original image. Due to its deterministic nature, the same plaintext blocks will always produce the same ciphertext blocks. However, both CBC and SEBCM modes make encrypted images that look pretty random, which hides the real image information well. SEBCM will eliminate pattern-revealing attacks, so it is great for encryption.

5.2. S-Box Security Evaluation

Two main methods of cryptanalysis were utilized in testing the proposed S-box design (linear and differential). In addition to this, a thorough analysis of all security properties including key sensitivity, randomness, bijectivity, and inter-key differences was performed in order to demonstrate the S-box construction’s complete cryptographic strength.

Figure 11 illustrates the cryptographically nonlinear distribution of 100,000 different S-Boxes that were generated from 100,000 distinct keys. The center of the distribution is tightly focused around the range of 104–105, which confirms a uniform level of cryptographic robustness across this S-box design.

5.2.1. Resistance to Linear Cryptanalysis

To quantify the level of non-linearity present in a large number of independently generated S-box instances created with random secret keys, we evaluated 100,000 randomly generated S-boxes. Nonlinearity is defined by the lowest Hamming distance between the sets of output Boolean functions produced by an S-box and the closest affine functions. A high degree of nonlinearity is critical to providing protection against linear cryptanalysis. The findings show that the strength and stability of the above-mentioned S-box’s cryptographic performance is considered very strong; with an average value of 104.50, a minimum value of 102, a maximum value of 106, and a standard deviation of 1.32, the suggested S-box consistently provides strong levels of resistance (as a minimum) when compared with the industry-standard S-box constructions.

For comparison, the AES S-box achieves a nonlinearity value of 112, which is the maximum attainable for 8 × 8 bijective S-boxes. While the proposed S-boxes do not reach this optimal value, the observed average nonlinearity of 104.5 remains high and indicates strong resistance to linear cryptanalysis.

5.2.2. Resistance to Differential Cryptanalysis

Differential uniformity was used to evaluate the performance of the new S-box designs. Differential uniformity measures how many times an output value can repeat from pairing it with the same input values, which is extremely important in resisting differential attack techniques. Each of the Sbox designs produced results exhibiting a low level of differential uniformity, with a mean of approximately 6.0, a low of 4.0, a high of 8.0, and a standard deviation of less than 1.0. The results provide clear evidence of the high degree of randomness and effective diffusion characteristics of these S-box designs, which result in the very low likelihood of being able to reliably forecast the output for a given input.

5.2.3. Practical Security Tests

Key Sensitivity Test

To determine the degree of influence that modifying one bit of the secret key would have on the output of the S-box design, it was necessary to analyze 255 entries out of 256 that changed as a result of the change to the key. This indicates that the key had a high degree of sensitivity. Such a high degree of sensitivity is essential to ensure that related-key and key recovery attacks do not succeed.

Randomness and Bijectivity Test

To provide for cryptographically secure systems, all generated S-boxes must have perfect bijections (i.e., they must be a permutation of 256 unique values). The analysis of all S-box designs produced confirmed this requirement for complete bijections and complete randomization, thereby ensuring the safety of the replacement and lack of vulnerability to fixed-point or repeating-mapping attacks.

Inter-Key Variation Test

To present a realistic dynamic encryption environment, an analysis was completed comparing 100 pairs of distinct keys. The average difference between the S-box pair entries produced generated reports of 254.95 entries on average, with a difference of between 251 and 256 entries, and a standard deviation of 0.96 entries. The findings indicate there is an extremely low level of inter-key correlation, which is an important characteristic of a dynamic encryption environment where there are frequent key changes. The boxplot of inter-key variation can be viewed in Figure 12. The boxplot presented in Figure 12 clearly illustrates consistently consistent high variation (close to 255 differing entries out of 256). This indicates inherent features, illustrating the robustness and effective potential unpredictability of the proposed S-box design in cryptographic applications.

5.2.4. Conclusion of Security Analysis

Considering the cryptographic strength taken as an inference from the evaluated tests, it is possible to mention that unpredictability is high with a noticeable responsiveness to key changes. Hence, the proposed S-box design can be considered appropriate for the modern cryptographic algorithms in order to secure communication protocols. Both the cryptographic and the respective runtime metrics demonstrate balanced security and efficiency.

5.3. Encryption Time Analysis

The encryption performance of three cipher modes (CBC, CTR, and SEBCM) is evaluated using the five symmetric cryptographic algorithms: AES-128, AES-192, AES-256, DES, and TDES. Table 5 illustrates the time taken in seconds for the encryption process. Plaintext of sizes 100, 1K, and 10K are referred to as small file, while the remaining plaintext of sizes 100K and 1M are considered as large file.

Figure 13 shows the pictorial representation for Table 5. The performance gap between the cipher modes is negligible for the small files, whereas it is significant for the large files, as evident from Table 5. The SEBCM-based cipher modes support both competitive performance relative to CTR for some applications and a greatly improved level of security over CBC. The AES-128 has the fastest performance of all AES algorithm families, as the size of the encryption key increases, the time to encrypt increases. The SEBCM has a much shorter encryption time when encrypting large file sizes compared to CBC mode. The exceptional benefit of SEBCM is that it reduces the total time needed to encrypt large files from 1673.73 s to 203.56 s, showing that SEBCM has the capacity to provide shorter encryption times even for complex algorithms like TDES.

The analysis of the SEBCM indicates that it provides consistent performance for all five different algorithms in terms of throughput. This guarantees that SEBCM will work well for encrypting large sets of files. The analysis of the encryption times for a large file of 1M demonstrates these characteristics. With SEBCM, the cipher mode chosen can change based on the amount of data being processed (i.e., the choice goes from CBC mode to SEBCM mode). Therefore, the higher the size of the data, the better SEBCM is for handling large data sets.

The SEBCM contains the ability to provide secure messaging on top of the ability to process messages concurrently without disrupting operations. From the perspective of the security and performance trade-off, SEBCM has developed a unique function to provide strong security without interfering with normal operations. To maximize security, high file sizes, efficiency, encryption times, algorithms’ complexities, and overall performances based on analyzed results, SEBCM provides a greater level of consistency and security through parallel operation than either CBC mode or CTR mode.

The CTR mode has shown improvement in performance across various configurations, primarily due to the simplified chaining structure of the DES and TDES algorithms that allow multiple blocks to be processed simultaneously. But, overall, the SEBCM provides the highest performance of the three modes. The SEBCM will provide better security to larger data sets, such as AES-256 and TDES, when compared to CTR mode, even though the encryption times of SEBCM for smaller data blocks are similar. This is due to the hybrid nature of SEBCM, which allows for a higher level of security without compromising the security of the chaining mechanism.

The analysis of performance shows that SEBCM is a better balance of greater security with greater operational efficiency as compared to CBC mode, especially when large amounts of data are processed. Although SEBCM has a slightly slower processing speed than CTR for small messages, it provides greater security than CBC mode. Therefore, SEBCM is an ideal solution for large-scale implementations where the security of the data is of utmost importance.

5.4. Decryption Time Analysis

The decryption performance of the three cipher modes (CBC, CTR, and SEBCM) was evaluated with five symmetric key algorithms: AES-128, AES-192, AES-256, DES, and TDES. Table 6 provides the measured decryption times in seconds for input sizes ranging from 100 to 1 million blocks.

SEBCM shows a consistent and safe way to decrypt in all configurations. When using AES-based schemes, SEBCM works just as well as CBC and CTR modes, especially when the data file size is large. For instance, SEBCM was able to decrypt AES-256 with 1 million blocks in 58.31 s, which is a little faster than CBC (70.27 s) and even faster than CTR (59.14 s). When the inputs are smaller (like 100 or 1K blocks), SEBCM takes a little longer to decrypt than CBC and CTR. This extra work is due to the setup overhead of decrypting the random number. SEBCM adds a little more overhead in terms of percentage, but it still works better than CBC when there are a lot of them. In particular, the SEBCM’s ability to decrypt TDES with 1 million blocks in 206.96 s was faster than that of CBC at 221.81 s; thus, while SEBCM would have some very slight latency associated with low volume applications, it is a highly secure algorithm and can withstand a high volume of traffic, making it a very good option for large scale supported deployments (also known as “large” and “enterprise”) in a secure manner.

SEBCM is an effective balance of both security and scalable solutions. Although it has a longer overall decryption time than CBC and CTR for small volume applications, its higher level of cryptographic guarantees and protection against tampering, along with its strong ability to process in parallel, greatly benefit next-generation secure communication systems.

Figure 14 shows the pictorial representation for Table 6. The overall decryption performance shows that SEBCM is efficient overall and provides a high level of confidence as a reliable encryption solution. The performance of SEBCM compared with the various forms of AES has afforded SEBCM high levels of competitive performance, in many use cases being equal to or better than the CBC and CTR methods. In particular, the AES192 showed significant performance advantages over CBC at larger block sizes (i.e., 1 million blocks) as it decrypted data faster than CBC, making SEBCM very valuable to clients requiring fast processing and secure data.

5.5. Discussion on Brute-Force Search Cost and Computational Overhead

The resistance of a symmetric encryption scheme to brute-force attacks is fundamentally determined by the size of its secret key. For a key of length k bits, an adversary must test up to $2^k$ candidate keys in the worst case. Since SEBCM uses the same secret key as the underlying block cipher, it does not increase the theoretical brute-force complexity beyond that of the base algorithm.

Nevertheless, SEBCM introduces a key-dependent S-box generation procedure and a randomized header structure that must be computed prior to encryption or decryption. For a legitimate user who possesses the correct secret key, this S-box is generated once per session and reused for all subsequent block operations. Hence, the additional cost is amortized and has minimal impact on normal usage.

In contrast, an adversary performing exhaustive key search must regenerate the S-box and header-dependent structures for every guessed key before attempting decryption. This introduces additional computational overhead per key trial, which can be observed in the measured execution times.

It is important to note that the increased brute-force time observed for SEBCM reflects additional implementation-level computation per key trial (e.g., S-box generation and initialization overhead), and does not imply any increase in the underlying key space or the theoretical complexity of exhaustive key search. The values in

Table 7. Per-key computational overhead under exhaustive key testing for DES using CBC and SEBCM modes.

No. of Keys Tested	CBC (ms)	SEBCM (ms)
100	1	18,826
1000	62	188,510
10,000	228	1,791,005
100,000	2900	17,700,137
1,000,000	28,091	168,014,814

show that SEBCM incurs significantly higher per-trial computational cost than CBC. This difference arises from the need to recompute the key-dependent S-box and process the randomized header components for each candidate key.

Figure 15 compares the per-key computational overhead of CBC and SEBCM modes under brute-force attack conditions.

It is important to emphasize that this increased per-trial cost does not expand the cryptographic key space and does not constitute a formal increase in brute-force resistance. Instead, it represents an implementation-level overhead that may slow naive or resource-constrained exhaustive search attempts. The theoretical security against brute-force attacks remains governed solely by the key size of the underlying block cipher.

Therefore, the reported measurements should be interpreted as computational overhead comparisons rather than as cryptographic security proofs. The primary security advantage of SEBCM lies in its probabilistic structure, resistance to pattern leakage, and parallelizable design, rather than in altering the fundamental complexity of key search.

5.6. Attack Resistance

This section provides significant insights on how the SEBCM survives through several cryptographic attacks. The first significant attack considered is the bit-flip attack. According to SEBCM, every ciphertext block is encrypted independently. During decryption, this typically ensures that any modification to even a single bit will affect only the corresponding plaintext block without any interference to other blocks. This strategy is treated as localized impact. Adopting this strategy turns the altered block into meaningless data during the decryption. However, the other surrounding blocks can provide valid plaintext. This indicates substantial data manipulation. This version of block cipher modes differs from the stream ciphers in which the bit-alterations are not immediately effective and subsequently may go unnoticed.

5.6.1. Bit-Flip Attack

In SEBCM, each ciphertext block is encrypted independently. As a result, a bit modification in a ciphertext block affects only the corresponding plaintext block after decryption, without propagating errors to other blocks. This property, known as error localization, improves robustness against error propagation but does not provide explicit tamper detection or integrity guarantees.

5.6.2. IV Modification Attack

SEBCM is highly resistant to header/IV tampering. Since the three random values embedded in the header are encrypted and S-box-substituted, even a one-bit modification causes a high-diffusion effect across all decrypted blocks. This makes the output of plaintext completely unreadable. Like PCBC mode, in this way, SEBCM makes sure that attackers cannot make predictable or localized changes by changing the header, which makes these kinds of attacks easy to spot.

5.6.3. Nonce/IV Reuse Attack

SEBCM eliminates IV reuse vulnerabilities by design. Every time you encrypt something, you get a different, random set of three values that make up an encrypted header. The dynamic S-box replaces these values, and the chances of getting the same header twice with the same key are very, very low. Also, since the header is internal and not provided by the user, there is no chance of it being used again by mistake. If an attacker replays the header, they would not be able to decrypt it without the exact key, which would make the reuse attack useless.

5.6.4. Replay Attack

The transformation function(F) in SEBCM stops replay attacks by tightly linking ciphertext blocks to their original index. Copying, reordering, or reusing the blocks from one encrypted message in a different context will give you the wrong plaintext because the transformation values used to decrypt are based on the original block index. So, replaying or moving blocks messes up the decryption process, making the output random and making the attack useless.

5.6.5. Error Propagation and Reliability

The significant contribution of the SEBCM is that it can mitigate the decryption errors. Usually, in CBC or PCBC, an error in a one ciphertext block propagates through the subsequent blocks, which subsequently leads to a complex decryption mechanism, while data corruption is the most obvious case. It is possible to get rid of this by incorporating block-wise isolation in SEBCM. This isolation limits the error in a block while the noise in the communication channel is restricted to its local environment. This mechanism enhances the fault tolerance, which is an essential feature that makes SEBCM suitable for lossy transmission environments, packet-switched networks and wireless communication systems, where data integrity and reliability are critical. Several attack strategies like bit-flipping, initialization vector modification, nonce reuse, replay attacks, and error propagation have been used to test the security efficiency of the proposed SEBCM. The proposed block cipher mode has outperformed and showed consistency in fault tolerance as it bounds the malicious attempts, either localized ones or decryption failure on the whole, with no structural information disclosed.

6. Conclusions

The proposed Secure and Efficient Block Cipher Mode (SEBCM) could address several long-standing challenges in block cipher designs. This includes parallelizability, randomness, fault tolerance, and minimal cryptographic overhead. The SEBCM has been successfully structured and compared with traditional modes such as CBC, ECB, and CFB in an environment that demands both robust security and high throughput. Accordingly, an S-box is integrated that is known for its position-specific transformation function, with a randomized encrypted header. The SEBCM could successfully balance cryptographic security and operational performance. The encryption and decryption time are recorded to test the computational efficiency of SEBCM and compared with the other popular cipher modes. The SEBCM provides support to block-wise parallel encryption and decryption. Hence, it possesses inherent compatibility and can easily work on modern computing architectures, like GPUs and multi-core processors. The validation and comparative analysis reported that the SEBCM is scalable, with faster execution than traditional modes that use serial chaining mechanisms. SEBCM achieved consistently lower (and highly competitive) encryption and decryption times, especially at high data volumes. It clearly outperformed CBC while being significantly comparable to CTR in large data systems. As the proposed mode could survive through the brute-force and other attacks in particular with a substantial resistance, it can be considered for applications that are critical and demand high security, for example, applications like military communication systems, healthcare data exchange, blockchain frameworks, and smart grids, which demand resistance to tampering.

7. Future Work

Integration with post-quantum cryptographic frameworks could be one scope of future work, while it has to be tested on long-term security against quantum computing threats. The scalability can be a significant feature for low-latency embedded systems and lightweight environments like IoT and sensor networks. Formal validation with mathematical security proofs may further strengthen the SEBCM’s suitability and its design. A real-time deployment and evaluation on distributed and cloud-based platforms can validate the proposed cipher mode in terms of scalability and interoperability in large, secure systems.