A Lightweight Image Encryption Scheme Using DNA Coding and Chaos

Abstract

Protecting transmitted multimedia data such as images is a significant concern. This work proposes an encryption algorithm for greyscale images using a Pseudo-Random Number Generator (PRNG), DNA coding, and pixel sum. The proposed approach is implemented on a Genesys 2 FPGA using minimal hardware resources and can operate at a maximum frequency of 110.8 MHz. In addition, several performance evaluation tests are conducted for multiple images, including statistical analysis of the encrypted image, keyspace analysis, and differential attack analysis. The system is compared to recent works with respect to encryption quality and used hardware resources. The proposed scheme outperformed recent chaos-based image encryption schemes.

1. Introduction

The scope of data transmission has broadened in recent years thanks to the rapid development of communications infrastructure such as mobile and internet networks. The public nature of internet networks means that this domain encounters extra difficulties due to unlawful eavesdropping when archiving and sharing multimedia data [1]. Images sent online should be encrypted to prevent snooping eyes from spying on the data. Effectively image encryption should offer high security and minimal complexity to ensure safe data transfer [2].

Deterministic chaos is a prevalent phenomenon observed in continuous-time dynamical systems governed by nonlinear differential equations. Chaotic systems are essential in a wide range of applications, including but not limited to the modelling of robots [3], motion control [4], and random number generation and encryption applications [5]. Chaotic systems have several advantages, such as sensitivity to parameters and initial conditions. Furthermore, the non-periodic nature of chaotic systems makes them ideal candidates for use in encryption systems [6]. Using chaotic cryptography to protect images has been proposed to solve numerous security problems [7]. An encryption image technique utilizing hyperchaotic maps and bit-level Arnold transformation was proposed in [8]. First, this method divides a grayscale image into eight binary images. Then, the images are shifted using a chaotic sequence. Following this, the Arnold transform is used. Lastly, the hyperchaotic map is used to apply image diffusion. Unfortunately, this system necessitates image division, which adds complexity and can prevent image optimization to functional hardware architecture. A true random number generator and a chaotic system were used in [9], which increases the system’s complexity and makes the hardware implementation less feasible. A technique of plaintext-related encryption based on two chaotic systems and DNA manipulation was proposed in [10]. The system relies on particular pixel values in the encryption process. However, this threatens image restoration if any of the selected pixel values are changed. An image encryption algorithm was proposed in [11] using DNA encoding, a hyperchaotic Lorenz system, and Arnold transformation for pixel permutation. The authors proposed a modification when using the Arnold transform in order to avoid its periodicity, which could have represented a weakness for the algorithm. A modified Henon 2D map and a sine map were presented in [12] as a hybrid chaotic technique, where a tent map, logistic map, and sine map were all combined.

The approach presented in [13] for encrypting images used a combination of one-dimensional logistic–tent maps for diffusion and two-dimensional sin–cosine cross-chaotic maps for confusion. Using a complicated wavelet transform, the authors of [14] proposed a 5D hyperchaotic system to encrypt color pictures. Then, a 5D chaotic map was employed to decrypt dispersed sub-bands. In [15], a new 6D hyperchaotic system for visually tunable encryption was presented. A random sequence generator combining three chaotic functions, including the sine chaotic function, was constructed in [16]. A linear congruence generator with the aforementioned random sequences was integrated to construct a resilient substitution matrix, then the resulting matrix was transmitted to a scrambler to augment the stochasticity of the elements. The utilization of discrete quantum steps as a means to create secure cryptographic applications was suggested in [17]. Quantum steps benefit from determinism and high sensitivity to initial conditions. These characteristics create opportunities for a novel approach to quantum hash functions, substitution matrices, and pseudorandom number generators. These components are integral to the implementation of quantum encryption and authentication protocols. In [17], the proposed substitution matrix was derived from a series of random values generated by performing one-dimensional single-particle quantum steps on a circular path. These were then arranged in sequential order, with the indices of their respective positions ultimately constituting the substitution matrix. A four-dimensional multiscroll modified Hopfield neural network (MHNN) utilising sign function polynomials was introduced in [18]. This novel approach was then employed in the field of medical digital watermarking. In [19], the authors developed an innovative memristor incorporating a signed function polynomial memductance. The researchers incorporated it into the Hodgkin–Huxley (HH) model, creating a memristive HH system that can generate multiscroll attractors. They then utilised this system in an image encryption application [19].

In [20], the authors developed an image encryption system with a chaotic block cypher. Their proposed approach employs a chaotic system to encrypt 256 block bits of a plain image. In [21], the authors enhanced the security and key space of the encryption system by integrating chaotic maps and a Linear Feedback Shift Register (LFSR) in a hybrid domain. In [22], the authors developed a system that utilises skew tent mapping and permutation–diffusion techniques to enhance security and expand the key space of the encryption system. In [23], the authors introduced encryption approaches that involve the initial shuffling of the original image using a two-dimensional hyperchaotic discrete system. Subsequently, the Chinese remainder theorem was employed to diffuse and compress the image. In addition, an image encryption system incorporating a circular substitution box and a key stream buffer was introduced in [23]. In [24], the authors employed a methodology that involved dividing the original image into overlapping blocks. They then performed random block shuffling and utilised the Arnold transform and a chaotic map to build a secure matrix for block-wise encryption. In [25], a novel approach to multiple-picture encryption was presented. This technique utilises the Henon map, logistic map, and bit-plane decomposition to convert four grayscale photos into an encrypted PNG image.

Lorenz chaos has been used to encrypt images due to its simplicity. The authors in [26] proposed a symmetric cryptosystem designed explicitly for colour images. Their approach employs a hybrid variant of the Lorenz system to facilitate dispersion while employing DNA sequencing techniques to introduce confusion. The authors of [27] utilised a Lorenz–Rossler chaotic system to conduct pixel diffusion while employing 2D logistic maps for confusion. In [28], the authors proposed an encryption system for RGB images that incorporates Shannon’s confusion and diffusion principles. The proposed strategy was executed using a three-stage process. The initial phase involves using cellular automation to generate the first key. During the second stage, an S-box introduces the necessary elements of nonlinearity and complexity. In the third stage, the second key is generated utilising a solution of the Lorenz system. The simplicity of the Lorenz chaotic system makes it easier to design hardware and reduces its cost.

In [7], the authors proposed a pseudorandom number generator based on the Modified Hopfield Neural Network (MHNN) algorithm. The PRNG was implemented on the Vivado design tool utilising Xilinx XC7Z020CLG400-2 FPGA hardware. The postprocessing unit of the pseudorandom number generator comprised a nonlinear postprocessor and an XOR calculator, with the latter depending on the MHNN chaotic oscillator. The initial dimensional output was utilised as input data to enhance the randomness level in the implemented pseudorandom number generator on the field-programmable gate array (FPGA). In [29], the authors proposed a hardware design for a grayscale image encryption algorithm. The proposed image encryption algorithm utilised pixel-level scrambling, bit-level scrambling, and pixel-value diffusion techniques. This objective was achieved by utilising a field-programmable gate array (FPGA)-based implementation of a chaotic system characterised by line equilibrium. The authors provided the hardware resources used for each of their systems. In [30], an image encryption algorithm was proposed based on a systolic array, and the design aimed for high speed.

Utilizing DNA and Lorenz’s chaotic system allows the hardware resources needed to make a robust image encryption algorithm to be reduced. Lorenz’s chaotic system consists of a few multiplication operations which can be changed to shift operations by making the parameters powers of two. Making parameters constant confines the chaotic system in a state that avoids dynamical degradation [31]. DNA coding and operations can be implemented using simple binary operations. Using both of these methods ensures the minimum hardware resources for image encryption without sacrificing the encryption quality. This paper proposes a DNA-based image encryption system utilizing chaos, DNA and pixel summation, and hardware implementation.

The rest of this paper is organized as follows. Section 2 reviews essential preliminaries of the concepts used in the proposed system. Section 3 describes the encryption and decryption systems. The hardware implementation is presented in Section 4. The results of various types of analysis for the encryption algorithm are discussed in Section 5 along with a comparison of the results to other algorithms. Finally, Section 6 concludes the work.

2. Preliminaries

2.1. Lorenz Chaotic System

The proposed cryptography system requires a source of pseudorandomness that can be generated on the transmitter side and regenerated on the receiver side. In order to realize the chaotic system in the digital domain, the digitization for the chaotic system is accomplished using Euler’s method [32] as shown in Figure 1. The following equations describe the Eulerian solution for the Lorenz chaotic system:

$$\begin{array}{cc}\hfill X_{n+1}& =X_n+h\sigma (Y_n-X_n),\hfill \end{array}$$

(1a)

$$\begin{array}{cc}\hfill Y_{n+1}& =Y_n+h(\rho X_n-Y_n-X_n{Z}_n),\hfill \end{array}$$

(1b)

$$\begin{array}{cc}\hfill Z_{n+1}& =Z_n+h(X_n{Y}_n-\beta Z_n),\hfill \end{array}$$

(1c)

where h is the step size, $\sigma$, $\rho$, and $\beta$ are the system parameters, and $X_0$, $Y_0$, and $Z_0$ are the system variables.

2.2. DNA Coding

The DNA encoding method is used to hide the value of each pixel. In a DNA sequence, there are four possible nucleic acid bases: cytosine (C), thymine (T), adenine (A), and guanine (G); ‘A’ is always complementary to ‘T’ and ‘C’ is always complementary to ‘G’ [33].

Table 1. DNA binary codes and their respective encoding and decoding rules.

DNA Base	Binary Code		Rules
			8	7	6	5	4	3	2	1
C	11	C	A	G	T	G	C	T	A	C
T	10	T	C	T	C	A	A	G	G	T
A	01	A	G	A	G	T	T	C	C	A
G	00	G	T	C	A	C	G	A	T	G

provides the relationships between the different DNA bases and the equivalent binary code. There are eight suitable coding rules between nucleic acid bases and the binary stream when complementary features of the binary stream are taken into account. Table 1 summarises the rules for DNA encoding and decoding used in the proposed cryptography system.

3. Cryptography Algorithm

3.1. Encryption

• Step 1: At the beginning, calculate the summation of all pixels in the image to produce $P_{Sum}$.
• Step 2: Calculate P which is equal to $mod(P_{Sum},16)$.
• Step 3: Divide the input key into eight keys, each of 32 bits ($Ke{y}_1...Ke{y}_8$).
• Step 4: XOR the keys with each other to generate the initial conditions for the chaotic sequence.
• Step 5: Run the Lorenz chaotic system using the initial conditions from the previous step, then discard the first 200 generated outputs to remove the redundancy.
• Step 6: Use the chaotic system outputs to generate $X_{bin1}$, $X_{bin2}$, $X_{bin3}$, $X_{bin4}$, $Y_{bin1}$, $Y_{bin2}$, $Y_{bin3}$, $Y_{bin4}$ such that $Y_{bin}$ is similar to $X_{bin}$ and $Z_{bin}$.
• Step 7: The pixel confusion process [34] is accomplished using the value of P. If P is even, then the image is encrypted normally; otherwise, the image is flipped and then encrypted. This is a simple method to change the pixel locations in each iteration.
• Step 8: Use $X_{bin1}$, $X_{bin2}$, $X_{bin3}$, and $X_{bin4}$ as the DNA encoding rule for every 2 bits of the input image.
• Step 9: Use $Y_{bin1}$, $Y_{bin2}$, $Y_{bin3}$, and $Y_{bin4}$ as the DNA decoding rule for every 2 bits of the DNA encoded bits generated from the previous step.
• Step 10: XOR the generated 8-bit output from step 8 with $Z_{bin}$ and $mask$, where $mask$ contains the previous output from step 10 and is initialized with zero. After this, $P=P-1$; return to step 5 and repeat until $P=0$.

The encryption algorithm is further explained in Algorithm 1. Assuming that the input to the algorithm is an image containing $LW$ pixels, then the estimated time complexity is bounded by $\mathcal{O}\left(LW\right)$.

Algorithm 1 Encryption process

Input: Input image $\mathbb{I}$, and encryption key $\mathbb{K}$

Output: Encrypted image $\mathbb{E}$, and the 16 bit value $\mathbb{P}$

1: $\mathbb{P}=mod\left(SUM\right(\mathbb{I}),16)$; 2: $P=\mathbb{P}$; //Divide the key into four 32-bit keys. 3: $\{Ke{y}_1,...,Ke{y}_8\}=\mathbb{K}$; //Set the initial conditions for the chaotic system. 4: while  $P>0$  do 5:    $X_0=Ke{y}_1\otimes Ke{y}_2\otimes Ke{y}_3\otimes Ke{y}_4$; 6:    $Y_0=Ke{y}_3\otimes Ke{y}_4\otimes Ke{y}_5\otimes Ke{y}_6$; 7:    $Z_0=Ke{y}_5\otimes Ke{y}_6\otimes Ke{y}_7\otimes Ke{y}_8$; 8:    for $i=1$ to (200 +$L\times W$) do 9:       $X=X_0+h\sigma (Y_0-X_0);$ 10:      $Y=Y_0+h(\rho X_0-Y_0-X_0{Z}_0);$ 11:      $Z=Z_0+h(X_0{Y}_0-\beta Z_0);$ 12:      $X_0=X;$ 13:      $Y_0=Y;$ 14:      $Z_0=Z;$ 15:      if $i>200$ then 16:         $X_{bin1}=mod(fix(X\times 2^{13}),8)+1$; 17:         $X_{bin2}=mod(fix(X\times 2^{16}),8)+1$; 18:         $X_{bin3}=mod(fix(X\times 2^{19}),8)+1$; 19:         $X_{bin4}=mod(fix(X\times 2^{22}),8)+1$; 20:         $Y_{bin1}=mod(fix(Y\times 2^{13}),8)+1$; 21:         $Y_{bin2}=mod(fix(Y\times 2^{16}),8)+1$; 22:         $Y_{bin3}=mod(fix(Y\times 2^{19}),8)+1$; 23:         $Y_{bin4}=mod(fix(Y\times 2^{22}),8)+1$; 24:         $Z_{bin}=mod(fix(Z\times 2^{22}),8)+1$; 25:         if $mod(P,2)==0$ then 26:           $I={\mathbb{I}}_i$; 27:         else 28:           $I={\mathbb{I}}_{(L\times W)-i}$; 29:         end if 30:         $D=DN{A}_{encode}(I,X_{bin1},X_{bin2},X_{bin3},X_{bin4})$; 31:         $T=DN{A}_{decode}(D,Y_{bin1},Y_{bin2},Y_{bin3},Y_{bin4})$; 32:         $\mathbb{I}\left(i\right)=Z_{bin}\oplus T\oplus mask$; 33:         $mask=\mathbb{I}\left(i\right)$; 34:         $P=P-1$ 35:      end if 36:    end for 37:    $\mathbb{I}=I$; 38: end while 39: $\mathbb{E}=I$; 40: return $\mathbb{E},\mathbb{P}$

3.2. Decryption

The decryption process is the inverse of the encryption process. The main difference is that P is not calculated; instead, it is sent to the receiver side along with the key.

4. Hardware Implementation

Figure 2 shows the hardware implementation for the proposed encryption system. ‘Enc_FSM’ controls all the blocks using the finite state machine (FSM), as shown in Figure 3. The initial conditions of the chaotic system are set using a 256-bit key. To reduce the resources used by the encryption algorithm, $\sigma$, $\rho$, and $\beta$ from Equation (Section 2.1) are set to 8, 16, and 2, respectively, in order to translate the multiplication operations to simple shift operations, as shown in Figure 4. ‘Block Memory’ contains the $512\times 512$ original image. Finally, the ‘Write Enable’ signal controls whether ‘Block Memory’ is written to or read from according to the ‘Address’ and ‘Data’ signals. The ‘Enc’ block contains the operations that the FSM implies. This is accomplished by a series of ‘Start_signals’ and ‘Flags’. After all of the cycles are finished, every 8 bits of the encrypted image are sent over the universal asynchronous receiver/transmitter (UART) to the personal computer (PC).

The FSM, shown in Figure 3, starts in the ‘IDLE’ state. When the ‘START’ signal arrives, the current state changes to ‘PSUM’. In ‘PSUM’, the memory outputs each pixel by incrementing the address to calculate the summation of each pixel in an 8-bit register ‘P’, as shown in Figure 5a. After that, the flag ‘F_PSUM’ is raised and the current state changes to ‘Discard_run’. In ‘Discard_run’, the chaotic system runs for 200 clock cycles to discard them, then the current state changes to ‘Clean_up’. The ‘Discard_run’ block diagram is shown in Figure 5b. After that, a ‘Clean_up’ operation occurs in which all registers are set to zero for two cycles. This allows the system to wait for the block memory to output the desired data, as it has a delay of two clock cycles. After that, DNA encoding and decoding are applied. In the ‘Mask’ state, the mask is calculated and ‘P’ is decremented by one; if it is equal to zero, the next state is ‘UART’, otherwise the next state is ‘Memory’. In the ‘Memory’ state, the generated data are saved in the block memory, then the address is incremented by 1. If it is the last address in the memory, the next state is ‘Discard_run’; otherwise, the next state is ’DNA’. In the ‘UART’ state, the data are transmitted to the PC and the address is incremented by 1.

The encryption system is implemented on Xilinx’s Genesys 2 FPGA using Verilog hardware description language (HDL). The proposed system can run at a maximum frequency of 110.8 MHz with a throughput of 147.73 Mbps.

Table 2. Encryption system hardware resource utilization.

Resources	Utilization	Utilization%
Lookup Tables (LUTs)	530	0.26
Flip Flops (FFs)	291	0.07
Block RAMs (BRAMs)	64	14.38
Digital Signal Processors (DSPs)	8	0.95

shows the resource utilization of the encryption system, where the resource utilization percentages for the LUTs, FFs, and DSPs are less than 1%.

Table 3. Encryption system hardware resource comparison.

Resources	This Paper	[7]	[29]	[30]
Lookup Tables (LUTs)	530	42,125	7681	38,273
Flip Flops (FFs)	291	52,050	8479	2371
Block RAMs (Mb)	2.25	-	-	1.12
Digital Signal Processors (DSPs)	8	-	-	63
Operating Frequency (MHz)	110.8	109.337	462.731	573

Best value in each category is in bold.

compares the hardware resources used in the proposed system to other works. The simplicity of the system and its use of pixel summuation, DNA, and Lorenz chaos reduces the LUTs required for a secure image encryption algorithm. The proposed algoritm uses more Block RAM, as it aims to encrypt $512\times 512$ images, while in [30] the system encrypted $300\times 300$ images. The system requires a low amount of resources, making it suitable for low-cost hardware devices.

5. Results and Discussion

The proposed system was tested using the grayscale ‘Lena’ $(256\times 256)$, ‘Pepper’ $(512\times 512)$, and ‘Baboon’ $(512\times 512)$ images. Figure 6 shows the original Baboon image and the same image after encryption using our proposed algorithm.

5.1. Statistical Analysis

5.1.1. Histogram

The histogram of the image represents the distribution of pixel values. A safe encryption technique should produce an encrypted image with a histogram that is nearly uniform in distribution. Figure 7 shows the histograms of the original and encrypted image using the proposed encryption scheme for the Lena, Baboon, and Pepper images. The histograms show the uniform distribution of the pixels for the encrypted images.

5.1.2. Peak Signal-to-Noise Ratio and Mean Square Error

To test the encryption quality, we measured the Peak Signal-to-Noise Ratio ($PSNR$) and the Mean Square Error ($MSE$), which are calculated as follows:

$$\begin{array}{cc}\hfill MSE& =\frac{1}{LW}\sum _{i=1}^L\sum _{j=1}^W{\left[O_{i,j}-E_{i,j}\right]}^2,\hfill \end{array}$$

(2a)

$$\begin{array}{cc}\hfill PSNR& =10{log}_{10}\frac{{(2^n-1)}^2}{MSE},\hfill \end{array}$$

(2b)

where $O_{i,j}$ and $E_{i,j}$ represent the original and encrypted images at location $(i,j)$, respectively, and n represents the number of bits per pixel. High $MSE$ and low $PSNR$ indicate a significant difference between the encrypted image and the original.

5.1.3. Correlation

The proximity between two neighbouring pixels in an image can be measured via correlation analysis. The neighbouring pixels in the original image are highly correlated across the diagonal, vertical, and horizontal axes. An ideal image encryption technique should lessen the degree to which neighbouring pixels are correlated with each other [35]. The following equations were used to calculate the correlation coefficients:

$$\begin{array}{cc}\hfill \rho =& {\displaystyle \frac{Cov(x,y)}{\sqrt{D\left(x\right)}\sqrt{D\left(y\right)}}},\hfill \end{array}$$

(3a)

$$\begin{array}{cc}\hfill Cov(x,y)=& {\displaystyle \frac{1}{LW}}\sum _{i=1}^{LW}\left(x_i-{\displaystyle \frac{1}{LW}}\sum _{i=1}^{LW}{x}_i\right)\left(y_i-{\displaystyle \frac{1}{LW}}\sum _{i=1}^{LW}{y}_i\right),\hfill \end{array}$$

(3b)

$$\begin{array}{cc}\hfill D\left(x\right)=& {\displaystyle \frac{1}{LW}}\sum _{i=1}^{LW}{\left(x_i-{\displaystyle \frac{1}{LW}}\sum _{i=1}^{LW}{x}_i\right)}^2,\hfill \end{array}$$

(3c)

$$\begin{array}{cc}\hfill D\left(y\right)=& {\displaystyle \frac{1}{LW}}\sum _{i=1}^{LW}{\left(y_i-{\displaystyle \frac{1}{LW}}\sum _{i=1}^{LW}{y}_i\right)}^2,\hfill \end{array}$$

(3d)

where $Cov(x,y)$ represents the covariance between pixels x and y, D represents the standard deviation, and $LW$ represents the number of pixels in the image. The correlation for the Baboon image is shown in Figure 8, and the results are provided in

Table 4. Performance analysis.

Reference	Encrypted Image	Encryption Quality Metrics		Correlation (× 102)			Entropy	The Robustness against The Differential Attacks
		MSE	PSNR	H	V	D		NPCR (%)	UACI (%)
This paper	Lena	7794	9.2127	1.10	-1.12	−0.49	7.9972	99.6466	33.4061
	Baboon	7244	9.5305	−0.04	−0.09	0.00	7.9998	99.5911	33.4432
	Pepper	8403	8.8862	−0.18	0.11	−0.15	7.9993	99.6071	33.4254
[11]	Lena	7828	9.1943	0.42	0.12	0.01	7.9973	99.6042	33.4204
	Baboon	7289	9.5041	−0.18	−0.07	−0.01	7.9993	99.6091	33.4791
	Pepper	8390	8.8931	0.17	−0.08	0.39	7.9991	99.6086	33.4612
[10]	Lena	7793	9.21	−0.18	0.11	−0.09	7.9975	99.6147	33.4723
	Baboon	7285	9.52	0.19	−0.41	−0.99	7.9992	99.6063	33.4565
	Pepper	8436	8.86	−0.63	−0.06	−0.46	7.9993	99.6112	33.4776
[9]	Lena	−	9.2645	−0.03	−0.07	−0.01	7.9977	99.60	33.45
[8]	Lena	−	−	−0.06	−0.39	0.16	7.9978	−	−
	Baboon	−	−	−0.23	−0.00	−0.15	7.9982	99.6056	33.4282
[29]	Lena	−	−	−0.28	-3.18	−0.43	7.9976	−	−
	Baboon	−	−	−0.44	−0.97	1.28	7.9972	−	−
	Pepper	−	−	−0.45	0.59	0.01	7.9971	−	−
[30]	Lena	−	−	−0.69	1.51	−0.06	7.9977	99.60	24.62
	Pepper	−	−	−0.29	−0.89	−0.73	7.9975	99.63	25.44

Best value in each category for each image is in bold.

, where the values are almost zero in the vertical, horizontal, and diagonal directions. This means that the pixels are uncorrelated, which is a desirable property in image encryption.

5.1.4. Information Entropy

The information entropy is the average amount of information represented by each pixel [35]. It is calculated as follows:

$$Entropy=-\sum _{i=0}^{255}P\left(i\right)lo{g}_{2}P\left(i\right),$$

(4)

where $P\left(i\right)$ represents the probability of i. The possible values for a pixel in a grayscale image are $2^8$; hence, 8 bits is the ideal entropy value, indicating that the information is evenly dispersed across all pixel values. Table 4 indicates that the encrypted image’s entropy approaches eight.

5.2. Differential Attack

To evaluate the efficacy of resistance to differential attacks, the Number of Pixel Change Rate ($NPCR$) and Unified Average Changing Intensity ($UACI$) tests were used [35]. These two tests explain the sensitivity of the encrypted image to minor modifications of the original image. The equations used to calculate the $NPCR$ and $UACI$ are as follows:

$$\begin{array}{cc}\hfill NPCR& =\frac{1}{LW}\sum _{i=1}^L\sum _{j=1}^{W}DE(i,j)\times 100\%,\hfill \end{array}$$

(5a)

$$\begin{array}{cc}\hfill UACI& =\frac{1}{LW}\sum _{i=1}^L\sum _{j=1}^W{\displaystyle \frac{\mid E_1(i,j)-E_2(i,j)\mid }{255}}\times 100\%,\hfill \end{array}$$

(5b)

$$\begin{array}{cc}\hfill DE(i,j)& =\left\{\begin{array}{cc}0,\hfill & \mathrm{if}{E}_1(i,j)=E_2(i,j),\hfill \\ 1,\hfill & \mathrm{if}{E}_1(i,j)\ne E_2(i,j),\hfill \end{array}\right.\hfill \end{array}$$

(5c)

where $E_1$ and $E_2$ represent the two images resulting from encrypting the original image and the original with minor modifications, L and W are the dimensions of the image, and $DE(i,j)$ represents the difference between the corresponding pixels in the encrypted copies of the original and updated images. Table 4 provides the $UACI$ and $NPCR$ values, which were calculated from the mean of 50 iterations. All of the $UACI$ and $NPCR$ values are near the optimum respective values of 33.46% and 99.61% [6]. Hence, the encryption method is sensitive to minor modifications to the pixels in the original image.

5.3. Known Plain-Text Attack

An adversary might attempt to use an entirely black or white image to find plausible patterns in a cryptographic model [36]. The proposed system can be used to apply a cipher to the black and white images. The ciphered images are illustrated in Figure 9, showing no visible patterns. The entropy values for the encrypted images are the same as other encrypted images, and the encrypted images’ correlation coefficients are near zero. The results shown in

Table 5. Entropy and correlation for encrypted black and white images.

Image	Entropy	Correlation ($\times {10}^2$)
		H	V	D
Black	0	-	-	-
Black encrypted	7.9993	−0.07	−0.06	0.02
White	0	-	-	-
White encrypted	7.9994	−0.07	0.06	−0.02

demonstrate that the proposed system is effective against such attacks.

5.4. The Key Space

The keyspace of an encryption algorithm must be very vast in order to withstand brute-force attacks. Therefore, the proposed approach has $2^{256}$ different keys, allowing it to resist this type of attack [35].

5.5. NIST SP-800-22 Test

The NIST 800-22 is a compilation of statistical tests designed to evaluate the efficacy of pseudorandom number generators (PRNGs), random number generators (RNGs), and random sequences. This test suite consists of a total of fifteen statistical tests. The determination of whether a sequence can be accepted as a random sequence is made based on the P-value generated after each test [37]. The NIST test was successfully applied using the encrypted Lena image, with the results presented in

Table 6. Lena NIST test results.

Test	p-Value	Result	PROP.	Result
BlockFrequency	0.834308	✓	1.000	✓
Serial	0.030184	✓	1.000	✓
FFT	0.025193	✓	1.000	✓
Frequency	0.000296	✓	1.000	✓
Runs	0.048716	✓	1.000	✓
RandomExcursions	0.191394	✓	0.992	✓
LongestRun	0.048716	✓	1.000	✓
Rank	0.437274	✓	1.000	✓
Universal	0.350485	✓	1.000	✓
CumulativeSums	0.592397	✓	1.000	✓
OverlappingTemplate	0.162606	✓	1.000	✓
NonOverlappingTemplate	0.358452	✓	0.991	✓
RandomExcursionsVariant	0.120878	✓	1.000	✓
ApproximateEntropy	0.162606	✓	1.000	✓
LinearComplexity	0.739918		1.000

.

6. Conclusions

The encryption algorithm employed in this paper is based on a Lorenz chaotic system and DNA manipulation. The encryption iterations are based on calculating the pixel summation for the whole image. This increases the encryption algorithm’s dependence on each bit of the input image, which protects the system against differential attacks. Our performance evaluations demonstrated the reliability and effectiveness of the proposed system. In addition, the design was implemented on FPGA, employing low hardware resources at a maximum frequency of 110.8 MHz, making it suitable for real-world application hardware implementations.