Color Image Encryption Algorithm Based on Dynamic Block Zigzag Transformation and Six-Sided Star Model

Abstract

As a result of the rise in network technology, information security has become particularly important. Digital images play an important role in network transmission. To improve their security and efficiency, a new color image encryption algorithm is proposed. The proposed algorithm adopts a classical scrambling–diffusion framework. In the scrambling stage, the dynamic block Zigzag transformation is designed by combining the chaotic sequence with the standard Zigzag transformation, which can dynamically select the transformation range and the number of times. It is used to scramble the pixel positions in the R, G, and B components. In the diffusion stage, the six-sided star model is established by combining the chaotic sequence and the six-sided star structure characteristics, which can store the 24 bits of the pixel in a defined order to realize bit-level diffusion operation. Experimental analyses indicate that our algorithm has the characteristics of high key sensitivity, large key space, high efficiency, and resistance to plaintext attacks, statistical attacks, etc.

1. Introduction

As information security has fully entered the digital age, digital images have become an important form of information transmission. Images are more vivid and intuitive, and the amount of information is larger compared with traditional text information. From the perspective of countries or enterprises, a large amount of sensitive information, such as scientific research, and financial and military secrets, is extremely vulnerable to attack or theft. From a personal point of view, images are an important medium for people to record their personal lives and daily communications. If measures are not taken to prevent them, cyber attackers can exploit network vulnerabilities to steal private information [1]. Therefore, the protection of digital image information is very important in theory and practice. The most intuitive means of protection is encrypting the plain image. However, the encryption efficiency of traditional encryption schemes used to encrypt images is low [2,3]. Therefore, it is crucial to study secure and efficient algorithms.

In recent years, the algorithms proposed by scholars for image encryption have been mainly based on chaos theory, optical transformation, DNA encoding, and compressed sensing. These theories are used to design various image encryption algorithms to change the pixel positions and values. Munazah et al. proposed an image encryption method based on double chaotic maps. The chaotic sequence generated by the chaotic system is used to change the image pixel positions [4]. Wang et al. designed an optical image cryptosystem. The quadratic phase and double phase methods are firstly applied to generate the phase-only hologram, and then it is encrypted. The encrypted image is finally obtained by learning the probability distribution [5]. Younes et al. proposed an image encryption algorithm based on genetic operations and chaotic DNA encoding, which applied the biological DNA theory to the algorithm, and designed a unique encoding method to change pixel values [6]. Yang et al. proposed an image encryption scheme based on compressive sensing, which firstly compresses the image and then encrypts it. To a certain extent, the space occupied by the image transmission is reduced to improve the scheme’s efficiency [7]. Although many image encryption algorithms have been proposed to date, most of them take a single grayscale image as the research object, and the security and efficiency of the algorithm cannot be guaranteed. In this paper, a new algorithm is proposed to improve security and efficiency.

The chaotic system has the advantages of being sensitive to the initial value, having good randomness, and is not easily cracked, all of which are consistent with the requirements of cryptography [8]. The chaotic system has been widely used and studied in image encryption [9,10,11]. In 1989, the mathematician Matthews firstly introduced chaos into encryption systems, and proposed and explained the concept of chaotic cryptography [12]. Compared with the traditional image encryption methods, the encryption method based on the chaotic system has higher encryption efficiency. Therefore, image encryption schemes based on chaotic systems have been proposed by more researchers [13,14,15]. Wang et al. used the improved one-dimensional (1D) Logistic map to scramble pixel positions [16]. Naskar P. K. et al. used the Logistic map for the diffusion operation [17]. However, at the same time, the cracking technology of illegal hackers is also becoming increasingly mature. If only a single chaotic system is used in the encryption algorithm, the cipher can be easily deciphered by illegal attackers. Therefore, designing an efficient and secure image encryption algorithm needs to combine the chaotic system with other encryption methods. The Sine-Exponent-Tent (SET) chaotic system [18] is used to obtain the chaotic sequence, and the parameters of the SET chaotic system are viewed as the master key in this paper. The SET chaotic system is secure for image encryption and is a well-known system due to its complex dynamic characteristic.

The standard Zigzag transformation is a scrambling method that starts from the upper-left corner of the elements in the matrix [19]. This transformation uses a “Z”-shaped path to store the scanned elements in a 1D array, and the 1D array is converted into a two-dimensional (2D) matrix in a particular manner. Many scholars have used the Zigzag transformation to realize the scrambling operation [20,21,22]. In the algorithm proposed by Chai et al., the 2D Zigzag transformation requires multiple global loops [23]. In the algorithm by Li et al., the 2D Zigzag transformation only has one starting point [24]. Zhang et al. proposed a new Zigzag transform algorithm [25]. To break the limitations of the square matrix, Wang et al. applied the Zigzag transformation to the non-square matrix to expand its scope of application [26]. To solve the problem of the single starting point, Wang et al. extended the starting point from the upper-left corner to the other three corners [27]. Although the standard Zigzag transformation can effectively scramble pixel positions, some adjacent values in special positions of the image cannot be scrambled, and the obvious horizontal texture characteristics and the high correlation coefficient lie in the horizontal direction. Therefore, the dynamic block Zigzag transformation is proposed in the scrambling stage.

The color image encryption (CIE) algorithm usually encrypts the three components of R, G, and B separately and then combines them into a color image [28]. Alternatively, a large grayscale image is combined by breaking up the three components, which encrypt and restore the original size [29]. Zhang et al. proposed a CIE algorithm based on image hashing, six-dimensional hyper chaos, and dynamic DNA encoding. Firstly, the color image is preprocessed, and the hash sequence is extracted by the hash algorithm, which is used as the initial value and control parameter of the chaotic system. Secondly, the three components of the color image R, G, and B are combined into a 2D matrix, followed by pixel replacement, DNA dynamic coding, and arithmetic operations. Finally, the encrypted image can be obtained by combining the three components [30].

Wang et al. proposed a CIE scheme based on a hash function, the discrete wavelet transform, and chaotic mapping. In this algorithm, the wavelet transform is used to decompose the three components in the plaint image into four sub-bands. These sub-bands are scrambled, reduced, inverted, and exchanged, and the image reconstructed by inverse discrete wavelet transform is further analyzed. Then, the encrypted images obtained by the three components are combined and recombined to obtain the required encrypted images [31]. Zhang et al. proposed an image-encrypting algorithm based on 3D Zigzag transformation and view planes, which adopted the classical scrambling–diffusion framework [32]. The chaotic sequences are generated by the pseudo-random number generator system to achieve the encrypted process. The pixel positions are changed by 3D Zigzag transformation and the pixel values are diffused by the view planes. After continuous research by countless scholars, CIE technology has gradually taken shape. By combining the chaotic system and the scrambling method, the scrambling–diffusion framework can meet most of the encryption needs. However, some space for improvement remains in the existing encryption algorithms.

To improve the security and efficiency, a new CIE algorithm is proposed. The main contributions of this paper are described as follows: (1) Combining the block principle and the standard Zigzag transformation, the dynamic block Zigzag transformation is proposed to change the pixel position in the R, G, and B components; (2) Inspired by the six-sided star, the six-sided star model is established to replace pixel values. This transformation can effectively realize pixel replacement and eliminate the correlation between pixels. A CIE algorithm is devised based on dynamic block Zigzag transformation and the six-sided star model, which can encrypt the color image. Our algorithm uses the classical scrambling–diffusion framework; (3) Experimental results and algorithm analyses verify the feasibility and superiority of the proposed algorithm.The remainder of this paper is arranged as follows: Section 2 presents definitions and theories. Section 3 proposes a new CIE algorithm. Section 4 presents the experimental results and analyses. Conclusions are drawn in Section 5.

2. Preliminary Works

The encrypted image is obtained through the encryption key and the encryption algorithm. The encrypted image is transmitted to the receiving end through the communication channel, and the key is transmitted through the secure channel. After the receiving finally obtains the encrypted image, the decryption algorithm and the decryption key are used to decrypt the encrypted image to obtain the plain images. During the transmission of the image, even if the encrypted image is attacked, it is difficult for the attacker to obtain the real information of the image without the decryption algorithm and decryption key. The encryption algorithm is designed based on the scrambling and diffusion operations, and the decryption algorithm is the inverse process of the encryption algorithm. The frame diagram is shown in Figure 1.

2.1. SET Chaotic System

The SET chaotic system can produce chaotic phenomena [17]. Its iterative formula is:

$$x_{i+1}=a\sin {(\pi x_i)}^{\ln (2b\min \{x_i,1-x_i\}+c)},$$

(1)

where i is the number of iterations, and a, b, are the control parameters. When a = 1.01, $b\in (0,1)$ and $c\in (2,3)$, the SET chaotic system is in the chaotic state.

The bifurcation diagram of the SET chaotic system is drawn in Figure 2 when the parameter c = 2.8316, and b ranges from 0 to 1. Figure 3 shows the bifurcation diagram when the parameter b = 0.8512, and c ranges from 2 to 3. This chaotic system behaves well and can be used for encryption algorithms.

2.2. Standard Zigzag Transformation

In the field of image encryption, the Zigzag transformation is a scrambling method for pixel dislocation. It is simple and its key period is large. The standard Zigzag transformation starts from the upper-left corner, and it is suitable for the square matrix [20]. The two matrices of 4 × 4 are illustrated in Figure 4 to represent the matrices before and after the standard Zigzag transformation.

2.3. Dynamic Block Zigzag Transformation

2.3.1. Algorithm Description

Multiple small-area dynamic block Zigzag transformation is designed to replace the standard Zigzag transformation for the entire image. The transformation performs several rounds in succession and the specific processes are described as follows.

Step 1: Generating scrambled blocks

The chaotic sequence is used to generate the coordinate values to limit the transformation blocks’ region range. The algorithm performs several rounds of transformation in succession. Each round has two pairs of coordinate values, which represents the scope of the Zigzag transformation in each round of blocks. When generating the point range, it is necessary to ensure that all points in the entire image can participate in at least one transformation.

A total of 4v numbers are taken from the chaotic sequence and converted into integers. According to Equations (2) and (3), they are changed into an integer stream in the range of [1, 1024], which is used to generate a coordinate of the limiting transform region range.

$$L^{\prime }=floor(L(1:4v)\times 10^8),$$

(2)

$$\left\{\begin{array}{c}X=\mathrm{mod}(L^{\prime }(1:v),1024)+1\\ Y=\mathrm{mod}(L^{\prime }(v+1:2v),1024)+1\\ Z=\mathrm{mod}(L^{\prime }(2v+1:3v),1024)+1\\ W=\mathrm{mod}(L^{\prime }(3v+1:4v),1024)+1\end{array}\right.,$$

(3)

where 4v >max (m, n).

In the i-th round of transformation, the numbers x_i, y_i, z_i, and w_i are taken from X, Y, Z, and W respectively. Two pairs of coordinates are generated using Equations (4) and (5), which represent the coordinates of the upper-left corner and the lower-right corner of the Zigzag transformation area, respectively. To ensure that the edge part can participate in the transformation, when the abscissa and ordinate values are less than or equal to 256, the value is 1, and when the value is greater than or equal to 768, the value is 512. The specific values are realized by the maximum and minimum functions.

$$\left\{\begin{array}{c}{x^{\prime }}_i=\min \left(\max \left(\left(x_i-256\right),1\right),512\right)\\ {y^{\prime }}_i=\min \left(\max \left(\left(y_i-256\right),1\right),512\right)\\ {z^{\prime }}_i=\min \left(\max \left(\left(z_i-256\right),1\right),512\right)\\ {w^{\prime }}_i=\min \left(\max \left(\left(w_i-256\right),1\right),512\right)\end{array}\right.,$$

(4)

$$\left\{\begin{array}{c}{l}_i=\min \left({x^{\prime }}_i,{z^{\prime }}_i\right)\\ r_i=\max \left({x^{\prime }}_i,{z^{\prime }}_i\right)\\ u_i=\min \left({y^{\prime }}_i,{w^{\prime }}_i\right)\\ o_i=\max \left({y^{\prime }}_i,w^{\prime }\right)\end{array}\right.,$$

(5)

where i is the number of the dynamic block Zigzag transformation rounds.

Step 2: Markup after scrambling

The Zigzag transformation is achieved about the area from (l_i, u_i) as the upper-left corner to (r_i, o_i) as the lower-right corner. An all-zero matrix Count of size m × n is used to mark each point participating in the transformation. Each time a region is scrambled, the value of all points in this region changes from 0 to 1.

Step 3: Judging and generating next round coordinates

The two pairs of coordinates for the next transformation are chosen from the coordinates outside the area. To judge whether Count (l_i+1, u_i+1) and Count (r_i+1, o_i+1) are all 0, assuming $Count\left(l_{i+1}, u_{i+1}\right)\ne 0$ or $Count\left(r_{i+1}, o_{i+1}\right)\ne 0$, take point (l_i+1, u_i+1) or (r_i+1, o_i+1) as the center, and search for points that are not 0 by circle diffusion in turn; this point is defined as the most recent point that has not been traversed.

Step 4: Stop scrambling

When all areas have participated in the transformation, that is, the sum of all coordinate points of the Count matrix is equal to m × n, the scrambling stops. The scrambled image can be obtained after transformation. The Algorithm 1 shows the scrambling process.

Algorithm 1: Image scrambling

Input: Image I, sequence L

Output: Scrambled image P 1:  P = I 2:  count = zeros(size(I)) 3:  L′ = floor(L(1:4v) × 108) 4:  X = mod(L′(1:v), 1024) + 1 5:  Y = mod(L′(v + 1:2v), 1024) + 1 6:  Z = mod(L′(2v + 1:3v), 1024) + 1 7:  W = mod(L′(3v + 1:4v), 1024) + 1 8:  cur = 1 9:  while sum(count)! = m × n do 10:   xi′ = min(max(X(cur) − 256, 1), 512) 11:   yi′ = min(max(Y(cur) − 256, 1), 512) 12:   zi′ = min(max(Z(cur) − 256, 1), 512) 13:   wi′ = min(max(W(cur) − 256, 1), 512) 14:    li = min(xi′, zi′) 15:    ri = max(xi′, zi′) 16:    ui = min(yi′, wi′) 17:    oi = max(yi′, wi′) 18:    P(li : ri : ui : oi) = zigzag(P(li : ri : ui : oi)) 19:    count(li : ri : ui : oi) = 1 20:    cur + + 21:  end while

2.3.2. Examples

(a) Finding the nearest not-traversed point

Taking the sixth-order matrix in Figure 5 as an example, search for the nearest points around point 15 that have not been traversed, and then search for point sets (8, 9, 10, 14, 16, 20, 21, 22), point sets (1, 2, 3, 4, 5, 7, 11, 13, 17, 19, 23, 25, 26, 27, 28, 29), and point sets (6, 12, 18, 24, 30, 31, 32, 33, 34, 35, 36) to determine if a point marked as 0 is the most recent point that has not been traversed.

Assuming that the nearest untraversed points of (l_i+1, u_i+1) and (r_i+1, o_i+1) are (l′_i+1, u′_i+1) and (r′_i+1, o′_i+1), respectively, these two points are substituted into Step 2 for the next round of scrambling.

(b) The dynamic block Zigzag transformation

Taking a sixth-order matrix as an example, the specific process of five rounds transformation is shown in Figure 6.

Step 1: The first round of transformation

The first round of transformation randomly generates point ranges (2, 2) and (3, 4), then Zigzag transformation is executed on the point set (8, 9, 10, 14, 15, 16) in this range to obtain the point set (8, 9, 14, 15, 10, 16).

Step 2: The second round of transformation

The second round of transformation randomly generates point ranges (3, 3) and (5, 5), then Zigzag transformation is executed on the point set (10, 16, 17, 21, 22, 23, 27, 28, 29) in this range to obtain the point set (10, 16, 21, 27, 22, 17, 23, 28, 29).

Step 3: The third round of transformation

The third round of transformation randomly generates point ranges (1, 1) and (2, 5), then Zigzag transformation is executed on the point set (1, 2, 3, 4, 5, 7, 8, 9, 14, 11) in this range to obtain the point set (1, 2, 7, 8, 3, 4, 9, 14, 5, 11).

Step 4: The fourth round of transformation

The fourth round of transformation randomly generates point ranges (2, 1) and (6, 3), then Zigzag transformation is executed on the point set (4, 9, 14, 13, 15, 10, 19, 20, 27, 25, 26, 23, 31, 32, 33) in this range to obtain the point set (4, 9, 13, 19, 15, 14, 10, 20, 25, 31, 26, 27, 23, 32, 33).

Step 5: The fifth round of transformation

The fifth round of transformation randomly generates point ranges (1, 5) and (6, 6), then Zigzag transformation is executed on the point set (3, 6, 11, 12, 21, 18, 17, 24, 29, 30, 35, 36) in this range to obtain the point set (3, 6, 11, 21, 12, 18, 17, 29, 24, 30, 35, 36).

After the above five rounds of transformation, all points of the original sixth-order matrix participate in the transformation. Due to the constant position of the four points in the upper-left and lower-right corners of Zigzag transformation, some points in the sixth-order matrix are not changed, but this phenomenon is significantly alleviated after extending to images of commonly used sizes and can be ignored.

One round of the dynamic block Zigzag transformation and ordinary Zigzag transformation is performed on an image of peppers, and the obtained scrambled image is shown in Figure 7. The correlation coefficients of its R, G, and B components are shown in

Table 1. Correlation coefficients of neighboring pixels after different Zigzag transformations (The bold part is the relevant value of the proposed algorithm.).

Transformation	Component	Horizontal	Vertical	Diagonal
Dynamic block Zigzag transformation	R	0.0688	0.0653	0.0541
	G	0.0550	0.0541	0.0495
	B	0.0305	0.0309	0.0208
Standard Zigzag transformation	R	0.9586	0.0957	0.0946
	G	0.9709	0.1653	0.1640
	B	0.9482	0.0568	0.0552

. The comparison shows that the dynamic block Zigzag transformation can greatly reduce the correlation of the transformed image, especially in the horizontal direction.

2.4. Six-Sided Star Model

The six-sided star model is used in the diffusion stage to change image pixel values [33]. Each pixel has three components, R, G, and B; that is, each pixel has a total of 24 bits. The 24 bits are marked as 1 to 24 in the order of R, G, B, and then from high to low, and they are arranged in the six-sided star model in the order of Figure 8. The six-sided star model can be divided into six regions. The specific diffusion process is described by Equation (6):

$$\left\{\begin{array}{l}{B}^1=A\left(1,2,4,5\right)\\ B^2=A\left(3,8,12,10\right)\\ B^3=A\left(18,16,19,14\right)\\ B^4=A\left(24,23,21,20\right)\\ B^5=A\left(22,17,13,15\right)\\ B^6=A\left(7,9,6,11\right)\end{array}\right.,$$

(6)

where A is the 24-bit value, and B¹, B², …, B⁶ are 4-bit values for the six regions.

B¹, B², …, B⁶ are calculated as follows:

$$\left\{\begin{array}{l}{C}^1=D\oplus B^1\\ C^2=C^1\oplus B^2\\ C^3=C^2\oplus B^3\\ C^4=C^3\oplus B^4\\ C^5=C^4\oplus B^5\\ C^6=C^5\oplus B^6\end{array}\right.,$$

(7)

where ⊕ indicates the exclusive or (XOR) operation, D is a 4-bit chaotic value, and the values of B¹, B², …, B⁶ are changed to obtain C¹, C², …, C⁶. The encrypted pixels can be obtained by restoring 24 bits of C to three components. In this way, the high-order and low-order bits inside the pixel are disturbed to realize the change in the pixel value. Algorithm 2 shows the six-sided star diffusion process.

Algorithm 2: Six-sided star diffusion

Input: Pixel A of 24 bits, squence D

Output: Transformed pixel C 1:   B1 = A.bitplaneof (1, 2, 4, 5), 2:   B2 = A.bitplaneof (3, 8, 12, 10), 3:   B3 = A.bitplaneof (18, 16, 19,14), 4:   B4 = A.bitplaneof (24, 23, 21, 20), 5:   B5 = A.bitplaneof (22,17, 13, 15), 6:   B6 = A.bitplaneof (7, 9, 6, 11), 7:   C1 = D⊕B1 8:   C2 = C1⊕B2 9:   C3 = C2⊕B3 10:  C4 = C3⊕B4 11:  C5 = C4⊕B5 12:  C6= C5⊕B6

Taking the pixels on the color image as an example, the pixel value of the R, G and B components are 108, 53, and 206. The values on the three components are converted to 24-bit binary numbers and stored in the six-sided star model. The six-sided star diffusion process is shown in Figure 9.

3. Proposed CIE Algorithm

The proposed CIE algorithm in this paper includes three stages. The first stage is the pre-encryption process to generate chaotic sequences. The second stage is the encryption process. The color plain image can be changed to the encrypted image. The third stage is the decryption process.

3.1. Pre-Encryption Process

Step 1: Generating the hexadecimal sequence

Let the original color image be I_m×n. Its R, G, and B components are I_R, I_G, and I_B, respectively. The 256-bit hash values corresponding to I_R, I_G, and I_B are calculated through the SHA-256 algorithm, and these hash values are converted into three 64-bit hexadecimal sequences S_R, S_G, and S_B, respectively.

Step 2: Generating the control values

The parameters b, c are generated with S_R, S_G, and S_B.

$$\left\{\begin{array}{l}{b}_1=hex2dec(\left[S_{\mathrm{R}}\left(1:4\right),S_{\mathrm{G}}(1:4),S_{\mathrm{B}}(1:4),S_{\mathrm{R}}\left(5:8\right),S_{\mathrm{G}}(5:8),S_{\mathrm{B}}(5:8)\right])\hfill \\ b_2=hex2dec(\left[S_{\mathrm{R}}\left(9:12\right),S_{\mathrm{G}}(9:12),S_{\mathrm{B}}(9:12),S_{\mathrm{R}}\left(13:16\right),S_{\mathrm{G}}(13:16),S_{\mathrm{B}}(13:16)\right])\hfill \end{array}\right.,$$

(8)

$$\left\{\begin{array}{l}{c}_1=hex2dec(\left[S_{\mathrm{R}}\left(17:20\right),S_{\mathrm{G}}(17:20),S_{\mathrm{B}}(17:20),S_{\mathrm{R}}\left(21:24\right),S_{\mathrm{G}}(21:24),S_{\mathrm{B}}(21:24)\right])\hfill \\ c_2=hex2dec(\left[S_{\mathrm{R}}\left(25:28\right),S_{\mathrm{G}}(25:28),S_{\mathrm{B}}(25:28),S_{\mathrm{R}}\left(29:32\right),S_{\mathrm{G}}(29:32),S_{\mathrm{B}}(29:32)\right])\hfill \end{array}\right.,$$

(9)

$$\left\{\begin{array}{l}bs=floor\left(\mathrm{mod}\left(b_1+b_2,10^{15}\right)\right)\hfill \\ cs=floor\left(\mathrm{mod}\left(c_1+c_2,10^{15}\right)\right)\hfill \end{array}\right.,$$

(10)

$$\left\{\begin{array}{l}b=\mathrm{mod}\left(bs\oplus b_0/2^{48},1\right)\hfill \\ c=\mathrm{mod}\left(cs\oplus c_0/2^{48},0.8\right)+2\hfill \end{array}\right.,$$

(11)

where $b_0,c_0\in (0,1)$ are external parameters, mod (·) denotes the modulus operation after division, floor (·) is the rounding toward negative infinity function, and hex2dec (·) denotes the conversion text representation of a hexadecimal number to a decimal number.

Step 3: Generating chaotic sequence

The control parameters b₁, c₁ and the initial values x₀ are generated in Step 2, and they are random values. Iteration is performed 1000 + 4v + m × n times according to Equation (1) and the first 1000 sequence values are discarded. A chaotic sequence L = {l_i} with the length m × n × 3 can be obtained.

3.2. Encryption Process

The preprocess generates the chaotic sequence by the color plain image. Then, the scrambled matrix is obtained by the dynamic block Zigzag transformation, and the cipher images are obtained by the six-sided star diffusion. Figure 10 shows the CIE flowchart, and the specific steps are described as follows.

Step 1: Dynamic block Zigzag transformation

L′ of 4v numbers are taken 4v from the chaotic sequence L to achieve the dynamic block Zigzag transformation, and the scrambled image P can be obtained after transformation.

Step 2: Generating chaos diffusion matrix

The subsequence L″ of length m × n from the chaotic sequence L is taken. L″ is transformed into an integer sequence, and then it is reshaped into an image matrix C with the size of m × n by Equation (13).

$$L^{″}=L[4v+1:4v+1+m\times n],$$

(12)

$$C=\mathrm{reshape}(\mathrm{mod}(floor(L^{″}\times {10}^8),16),m,n),$$

(13)

$$C^{\prime }=dec2bin(C),$$

(14)

where dec2bin (·) denotes the conversion text representation of a decimal number to a binary number. Each value of C′ consists of four binary digits.

Step 3: Rearrangement of bits

The R, G and B components of P_{i, j} are connected in order on the bits, and a 24-bit sequence is obtained. P_{i, j} is stored in the six-sided star model in order and divided into six parts, namely, F¹_{i, j}, F²_{i, j}, …, F⁶_{i, j}. Specifically, they are shown in Equation (15).

$$\left\{\begin{array}{l}{F}_{{}_{i,j}}^1=P_{i,j}\left(1,2,4,5\right)\\ F_{{}_{i,j}}^2=P_{i,j}\left(3,8,12,10\right)\\ F_{{}_{i,j}}^3=P_{i,j}\left(18,16,19,14\right)\\ F_{{}_{i,j}}^4=P_{i,j}\left(24,23,21,20\right)\\ F_{{}_{i,j}}^5=P_{i,j}\left(22,17,13,15\right)\\ F_{{}_{i,j}}^6=P_{i,j}\left(7,9,6,11\right)\end{array}\right.,$$

(15)

where i = 1, 2, …, m; j = 1, 2, …, n.

Step 4: Six-sided star model diffusion

The corresponding bits in R_{i, j} are calculated according to Section 2.4, as shown in Equation (16).

$$\left\{\begin{array}{l}{R}_{{}_{i,j}}^1={C^{\prime }}_{i,j}\oplus F_{{}_{i,j}}^1\\ R_{{}_{i,j}}^2=F_{{}_{i,j}}^2\oplus R_{{}_{i,j}}^1\\ R_{{}_{i,j}}^3=F_{{}_{i,j}}^3\oplus R_{{}_{i,j}}^2\\ R_{{}_{i,j}}^4=F_{{}_{i,j}}^4\oplus R_{{}_{i,j}}^3\\ R_{{}_{i,j}}^5=F_{{}_{i,j}}^5\oplus R_{{}_{i,j}}^4\\ R_{{}_{i,j}}^6=F_{{}_{i,j}}^6\oplus R_{{}_{i,j}}^5\end{array}\right.,$$

(16)

where ⊕ indicates the XOR operation, and the encrypted matrix E can be obtained by restoring 24 bits of R_{i, j} to three components. The size is m × n × 3. Algorithm 3 shows the Encryption process.

Algorithm 3: Encryption process

Input: Plain image I, hash sequences, SR, SG, and SB

Output: Cipher image E 1:   b1 = hex2dec([SR(1:4),SG(1:4),SB(1:4),SR(5:8),SG(5:8),SB(5:8)]) 2:   b2 = hex2dec([SR(9:12),SG(9:12),SB(9:12),SR(13:16),SG(13:16),SB(13:16)])′ 3:   c1 = hex2dec([SR(17:20),SG(17:20),SB(17:20),SR(21:24),SG(21:24),SB(21:24)]) 4:   c2 = hex2dec([SR(25:28),SG(25:28),SB(25:28),SR(29:32),SG(29:32),SB(29:32)])′ 5:   bs = floor(mod(b1 + b2,1015)) 6:   cs = floor(mod(c1 + c2,1015))′ 7:   b = mod(bs×b0/248, 1) 8:   c = mod(cs×c0/248, 0.8) + 2′ 9:   L = SET(1, b, c, 1000:1000 + mn + 4v) 10:  L′ = L(1:4v) 11:  for t = 1 to 3 do: 12:  P(:,:,t) = Image scrambling (I(:,:,t),floor(L(1000 + (t−1)*200:1000 + t×200))) 13:  end for 14:  L″ = L(4v + 1:4v + mn) 15:  C = reshape(mod(floor(L″×108),16), m, n) 16:  C′ = dec2bin(C) 17:  R = Six-sided star diffusion (P, C′) 18:  E = reshape (R, m, n,3)

3.3. Decryption Process

The decryption process is the inverse process of image encryption. The decryption flowchart is shown in Figure 11. The plain image I can be obtained according to the key and E by the inverse process. C and E are subjected to the XOR operation and the inverse XOR operation according to Equations (12)–(16) to obtain the scrambled image P. The dynamic block Zigzag inverse transformation is performed to restore the original image I.

4. Simulation Experiments and Results

4.1. Simulation Experiments and Results

The encryption algorithm was run on MATLAB R2018b. The hardware environment was a 1.20 CPU processor and 8GB memory. The software environment was the 64-bit Windows 10 operating system. The external parameters were b₀ = 0.7391, c₀ = 0.4183. The initial value was x₀ = 0.6715, and the control parameters were b = 0.7928, c = 2.3841. The color plain images were converted into encrypted images through the proposed algorithm. Some color plain images having the size of 512 × 512 were selected to achieve the experiments of the CIE algorithm, including Peppers, Baboon, Airplane, House, Penguin, Sky, Railway, Sea, Water, and Building. These were taken from the SIPI image database of the University of Southern California (http://sipi. usc.edu/database (accessed on 2 May 2022)). The Universal Resource Locator (URL) of the images can be seen in

Table 2. The URL of the plain images.

Name	URL
Peppers	http://sipi. usc.edu/database/4.2.07 (accessed on 2 May 2022)
Baboon	http://sipi. usc.edu/database/4.2.03 (accessed on 2 May 2022)
Airplane	http://sipi. usc.edu/database/4.2.05 (accessed on 2 May 2022)
House	http://sipi. usc.edu/database/house (accessed on 2 May 2022)
Penguin	http://sipi. usc.edu/database/4.2.04 (accessed on 2 May 2022)
Sky	http://sipi. usc.edu/database/2.1.01 (accessed on 2 May 2022)
Railway	http://sipi. usc.edu/database/2.1.02 (accessed on 2 May 2022)
Sea	http://sipi. usc.edu/database/2.1.03 (accessed on 2 May 2022)
Water	http://sipi. usc.edu/database/2.1.04 (accessed on 2 May 2022)
Building	http://sipi. usc.edu/database/2.1.05 (accessed on 2 May 2022)

. Figure 12a–j shows the color plain images. Figure 13a–j shows the encrypted images of the color plain images. Figure 14a–j shows the decrypted images.

4.2. Algorithm Analyses

In this section, we analyzed a variety of indicators in detail, and compared some indicators with other references. These include image encryption algorithms based on chaos and AES.

4.2.1. Key Space Analysis

For an encryption system, the key space of the system is necessary, and is a critical indicator to verify the algorithm security. The system of large key space can effectively resist the brute-force attack. The key space of this algorithm is about 10^14×2 × 2²⁵⁶ ≈ 2⁴³⁵, including the 256-bit hash values and b₀, c₀. It is much larger than the required value 2¹⁰⁰ [34]. It can be shown that the key space is large enough to effectively resist the brute-force attack.

Table 3. Key space comparison.

Algorithm	Proposed	Ref. [31]	Ref. [35]	Ref. [36]	Ref. [37]	Ref. [38]	Ref. [39]
Key space	2435	2349	2256	2128	2391	2366	2192

shows the comparison of the key space with that of other references.

4.2.2. Key Sensitivity Analysis

Key sensitivity analysis is an important indicator that can be used to verify the algorithm security. The encrypted images using different sets of keys to decrypt the results are completely different. Figure 15a shows the decrypted image of Peppers with the correct key. Figure 15b–d shows the decrypted image of Peppers with the incorrect key.

One number in the key changes slightly and the others remain the same. Figure 15b only changes the value of x₀ = 0.6715 to 0.6715 + 10⁻¹⁴. Figure 15c only changes the value of b₀ = 0.7391 to 0.7391 + 10⁻¹⁴. Figure 15d only changes the value of c₀ = 0.4183 to 0.4183 + 10⁻¹⁴. The decrypted images show that the image decrypted with the wrong key has no relationship with the plain image, and

Table 4. Difference between decryption results from slightly modified keys.

Figure	Decrypted Key	Pixel Difference Ratios
Figure 15a	the correct key	0.0%
Figure 15b	0.6715 + 10−14	99.6193%
Figure 15c	0.7391 + 10−14	99.6374%
Figure 15d	0.4183 + 10−14	99.6502%

shows the difference between the incorrectly decrypted image and the plain image. Therefore, the keys are highly sensitive in our algorithm.

4.2.3. Histogram Analysis

The unvarying dissemination is necessary for an excellent CIE algorithm. Otherwise, some information of the plain image cannot resist common statistical attacks [40]. An image histogram shows the number of pixels for each intensity value [41].

Figure 16 shows the pixel value histogram of each of the ten images in the experiment, and Figure 17 shows the histogram of each encrypted image corresponding to the plain image. The histograms of the plain images show large fluctuations and obvious characteristics. The histograms of the encrypted images are uniform. Therefore, the attacker cannot use the histogram distribution characteristics of the image to analyze the information characteristics of the image, and our algorithm can effectively resist statistical attacks.

4.2.4. The Plain Image Sensitivity Analysis

The principle of differential attack is that the attacker uses the encryption algorithm to process two different original images, and then obtains two cipher images [42,43].

To prevent the differential attack, a secure algorithm should ensure that the cipher images are completely different. The Number of Pixels Change Rate (NPCR) reflects the number of changed pixels in the cipher image after the plain image is changed. It is defined by:

$$NPCR=\frac{1}{m\times n}\times {\displaystyle \sum _{i=1}^m{\displaystyle \sum _{j=1}^{n}D\left(i,j\right)}}\times 100\%,$$

(17)

$$D(i,j)=\left\{\begin{array}{c}0C(i,j)=C^{\prime }(i,j)\\ 1C(i,j)\ne C^{\prime }(i,j)\end{array}\right.,$$

(18)

where C (i, j) is the unmodified plain image, and only one pixel is different between C′(i, j) and C (i, j).

The Unified Average Changing Intensity (UACI) measures the average difference intensity of pixel values between two cipher images, which correspond to the original image and the changed original image. It is defined by:

$$UACI=\frac{1}{255\times m\times n}\times {\displaystyle \sum _{i=1}^m{\displaystyle \sum _{j=1}^n\left|C\left(i,j\right)-C^{\prime }\left(i,j\right)\right|}}\times 100\%.$$

(19)

The Blocked Average Changing Intensity (BACI) was used to quantitatively evaluate the difference between two images of the same size. It is defined by:

$$BACI(P_1,P_2)=\frac{1}{(m-1)(n-1)}{\displaystyle \sum _{i=1}^{(m-1)(n-1)}\frac{m_i}{255}}.$$

(20)

To evaluate the sensitivity of our algorithm to plain images, NPCR, UACI and BACI were used. Their ideal values are 99.61%, 33.46%, and 26.77%, respectively [44,45].

For the color plain image Peppers in Figure 12a, the pixel values of five different positions in the R, G and B components were changed, and the NPCR, UACI, and BACI of the cipher image were calculated when one pixel was changed and not changed. The results and statistical analyses are listed in

Table 5. Results of NPCR, UACI and BACI at different locations in the Peppers image.

Position		(1,1,1)	(1,128,1)	(128,256,2)	(256,384,1)	(384,512,3)
Changing Pixel Values		$126\to 127$	$99\to 104$	$182\to 183$	$57\to 66$	$31\to 140$
NPCR (%)	R	99.6532	99.6128	99.6136	99.6162	99. 613
	G	99.6281	99.6082	99.6121	99.6072	99.6152
	B	99.6109	99.6431	99.6250	99.6223	99.6174
UACI (%)	R	33.5062	33.4421	33.4151	33.3957	33.5421
	G	33.4801	33.5053	33.3823	33.4416	33.5206
	B	33.4136	33.4147	33.5207	33.4723	33.4361
BACI (%)	R	26.7321	26.7021	26.7851	26.6861	26.8538
	G	26.7674	26.7923	26.7714	26.7442	26.7924
	B	26.7542	26.7531	26.7431	26.7905	26.7835

,

Table 6. Statistical results of NPCR in Table 5.

Component	Min (%)	Max (%)	Avg (%)	Passing Rate (%)
				$\mathit{N}\mathit{P}\mathit{C}\mathit{R}=99.5693\pm 0.05$	$\mathit{N}\mathit{P}\mathit{C}\mathit{R}=99.5527\pm 0.01$
R	99.5801	99.6326	99.6173	100	100
G	99.5923	99.6291	99.6182	100	100
B	99.5872	99.6352	99.6191	100	100

,

Table 7. Statistical results of UACI in Table 5.

Component	Min (%)	Max (%)	Avg (%)	Passing Rate (%)
				$\mathit{U}\mathit{A}\mathit{C}\mathit{I}=33.2824\pm 0.05$	$\mathit{U}\mathit{A}\mathit{C}\mathit{I}=33.2255\pm 0.01$
R	33.3103	33.5425	33.4541	100	100
G	33.3815	33.5317	33.4686	100	100
B	33.3802	33.5263	33.4535	100	100

,

Table 8. Comparison of NPCR and UACI using image Peppers (The bold part is the relevant values of the proposed algorithm).

Algorithm	NPCR (%)			UACI (%)
	R	G	B	R	G	B
Proposed	99.6080	99.6086	99.6205	33.4585	33.3721	33.4012
Ref. [30]	99.6107	99.6093	99.6085	33.4741	33.4818	33.4806
Ref. [25]	99.5934	99.6048	99.6109	33.3120	33.3916	33.4853
Ref. [46]	99.6000	99.5721	99.5628	33.5209	33.6773	33.6317
Ref. [47]	99.6491	99.6921	99.6534	33.4102	33.4077	33.3812
Ref. [48]	99.6167	99.6046	99.6158	33.4395	33.4587	33.4566
Ref. [35]	99.6200	99.6204	99.6219	33.3806	33.2179	33.4472
Ref. [36]	99.6134	99.5906	99.6332	33.2348	33.3003	33.5421

and

Table 9. Statistical results of BACI in Table 4.

Statistical Data	BACI (%)
	R	G	B
Average value	26.7528	26.7705	26.7538
Standard deviation	0.0445	0.0281	0.0294

, respectively. It can be seen from these tables that a small change in the plain image will lead to a huge difference in the cipher image. Both NPCR and UACI tests passed the hypothesis test, and the BACI value was also close to the ideal value. Therefore, the proposed algorithm can effectively resist differential attacks.

4.2.5. Correlation of Adjacent Pixels

The correlation coefficient is defined by [49]:

$$r_{x,y}=\frac{E((x-E(x))(y-E(y)))}{\sqrt{D(x)D(y)}},$$

(21)

$$E(x)=\frac{1}{N}{\displaystyle \sum _{i=1}^N{x}_i},$$

(22)

$$D(x)=\frac{1}{N}{\displaystyle \sum _{i=1}^N}{(x_i-E(x))}^2,$$

(23)

where x and y are the adjacent pixel values, and D(x) and E(x) are the variance and mathematical expectation of x, respectively.

Figure 18 and Figure 19 show the correlation diagrams of adjacent pixels in the horizontal, vertical, and diagonal directions of the R component of each plain image and its corresponding cipher image. It can be seen from Figure 18 that the points in all directions of the plain image are concentrated near the diagonal line, that is, the adjacent pixel values are very close, showing a high correlation. In Figure 19, the correlation graph of the cipher image shows an even distribution in the entire plane, which proves that the encryption algorithm can successfully eliminate the correlation between adjacent pixels in the plain image.

The correlation coefficient results between the plain image and the corresponding cipher image are shown in

Table 10. Correlation coefficient values of adjacent pixels in three different directions.

Image	Component	The Plain Images			The Encrypted Images
		Horizontal	Vertical	Diagonal	Horizontal	Vertical	Diagonal
Peppers	R	0.9585	0.9646	0.9533	−0.0059	0.0028	0.0007
	G	0.9780	0.9774	0.9644	−0.0002	−0.0037	0.0031
	B	0.9647	0.9608	0.9423	0.0055	0.0016	−0.0050
Baboon	R	0.9427	0.8758	0.8503	0.0005	−0.0047	0.0006
	G	0.9139	0.8170	0.7770	0.0004	−0.0005	−0.0001
	B	0.9489	0.8936	0.8691	−0.0007	0.0008	0.0002
Airplane	R	0.9752	0.9646	0.9533	0.0019	0.0017	0.0012
	G	0.9670	0.9714	0.9604	−0.0012	0.0016	0.0011
	B	0.9771	0.9678	0.9453	0.0025	−0.0028	−0.0051
House	R	0.9507	0.9586	0.9526	−0.0027	−0.0013	0.0009
	G	0.9611	0.9474	0.9602	−0.0009	0.0015	0.0021
	B	0.9593	0.9602	0.9413	0.0023	0.0008	−0.0010
Penguin	R	0.9662	0.9606	0.9567	−0.0019	−0.0037	0.0007
	G	0.9703	0.9574	0.9652	−0.0022	0.0016	0.0001
	B	0.9669	0.9613	0.9491	0.0055	−0.0006	0.0011
Sky	R	0.8813	0.8657	0.8492	−0.0009	−0.0005	0.0015
	G	0.8840	0.8675	0.8593	−0.0047	0.0072	0.0012
	B	0.8791	0.8638	0.8570	0.0001	−0.0003	−0.0011
Railway	R	0.8478	0.8339	0.7682	−0.0017	−0.0006	0.0038
	G	0.7837	0.7634	0.6819	−0.0016	0.0076	−0.0004
	B	0.7477	0.7253	0.6423	−0.0022	−0.0003	−0.0007
Sea	R	0.8983	0.9133	0.8558	0.0046	0.0030	0.0024
	G	0.8169	0.8486	0.7496	−0.0008	0.0035	0.0008
	B	0.7878	0.8145	0.7222	0.0029	−0.0011	−0.0017
Water	R	0.8422	0.8554	0.7825	0.0019	0.0000	0.0023
	G	0.7550	0.7798	0.6780	−0.0013	−0.0003	−0.0041
	B	0.6760	0.7086	0.5845	0.0065	0.0042	0.0013
Building	R	0.9577	0.9594	0.9372	−0.0008	0.0013	0.0004
	G	0.9368	0.9411	0.9126	−0.0019	−0.0009	0.0004
	B	0.9221	0.9278	0.8966	0.0039	0.0027	−0.0039

. The correlation coefficient values of the plain image in three directions are all close to 1, indicating that the adjacent pixels of the plain image are strongly correlated. The correlation coefficient values of the cipher image in the three directions are all close to 0, and the correlation is very weak. In addition, from the comparison results in

Table 11. Correlation coefficients of Peppers (The bold part is the relevant values of the proposed algorithm.).

Directions	Component	The Encrypted Images
		Horizontal	Vertical	Diagonal
Peppers	R	0.9585	0.9646	0.9533
	G	0.9780	0.9774	0.9644
	B	0.9647	0.9608	0.9423
Proposed	R	−0.0059	0.0028	0.0007
	G	−0.0002	−0.0037	0.0031
	B	0.0055	0.0016	−0.0050
Ref. [30]	R	−0.0029	−0.0043	−0.0007
	G	−0.0074	−0.0010	0.0007
	B	−0.0037	0.0028	0.0012
Ref. [25]	R	−0.0007	−0.0012	0.0022
	G	0.0007	−0.0012	0.0022
	B	0.0007	−0.0012	0.0022
Ref. [46]	R	0.0006	−0.0012	0.0052
	G	−0.0035	−0.0017	0.0021
	B	0.0025	−0.0023	−0.0008
Ref. [47]	R	−0.0022	−0.0010	0.0003
	G	0.0004	−0.0020	−0.0009
	B	0.0005	0.0002	−0.0012
Ref. [48]	R	−0.0032	0.0025	−0.0005
	G	0.0005	0.0021	−0.0017
	B	0.0011	0.0020	0.0025
Ref. [35]	R	0.0047	0.0025	0.0014
	G	0.0038	0.0040	0.0033
	B	0.0052	0.0009	0.0021
Ref. [36]	R	0.0147	−0.0037	−0.0306
	G	−0.0021	0.0035	0.0171
	B	0.0027	−0.0219	0.0044

, it can be seen that the performance of the proposed algorithm is better than that of other algorithms.

4.2.6. Information Entropy Analysis

The entropy of a digital image is a random estimate used to measure the sharpness of the histogram peaks [32,40]. Its mathematical definition is described by:

$$H\left(I\right)={\displaystyle \sum _{i=0}^{255}p\left(m_i\right){\log }_2\frac{1}{p\left(m_i\right)}},$$

(24)

where p(m_i) denotes the pixel gray level m_i.

The ideal value of H(I) is 8. The value the closer to 8, the more secure the image information.

Table 12. Information entropy values.

Algorithm	Entropy of Plain Images			Entropy of Encrypted Images
	R	G	B	R	G	B
Peppers	7.3388	7.4962	7.0583	7.9992	7.9994	7.9993
Baboon	7.7400	7.7025	7.1552	7.9993	7.9993	7.9993
Airplane	7.3061	7.4157	7.3427	7.9993	7.9994	7.9992
House	7.2113	7.4386	7.5215	7.9994	7.9994	7.9994
Penguin	7.5393	7.6722	7.3207	7.9993	7.9994	7.9994
Sky	7.5090	7.3541	6.5966	7.9993	7.9993	7.9993
Railway	7.4016	7.4188	6.5931	7.9994	7.9993	7.9993
Sea	6.5476	5.7003	4.5030	7.9992	7.9994	7.9992
Water	7.2621	6.6163	5.2736	7.9992	7.9992	7.9994
Building	7.5580	7.4596	6.6664	7.9993	7.9993	7.9994

lists the entropy values of four plain images in Figure 12a–j and corresponding ciphers.

Table 13. Comparison of information entropy with other algorithms (The bold part is the relevant values of the proposed algorithm.).

Algorithm	Entropy of Plain Images			Entropy of Encrypted Images
	R	G	B	R	G	B
Proposed	7.2978	7.3417	7.5142	7.9992	7.9994	7.9993
Ref. [30]				7.9994	7.9994	7.9994
Ref. [25]				7.9974	7.9974	7.9974
Ref. [46]				7.9972	7.9969	7.9973
Ref. [47]				7.9998	7.9998	7.9998
Ref. [48]				7.9994	7.9994	7.9994
Ref. [35]				7.9991	7.9991	7.9991
Ref. [36]				7.9992	7.9993	7.9993

shows that the information entropy values of the proposed algorithm and the comparative literatures are close to 8. Therefore, the proposed algorithm is secure in terms of entropy.

4.2.7. Occlusion Attack Analysis

An ideal cryptosystem should protect against data loss attacks during transmission and storage [50]. To measure the ability of this algorithm to resist data loss during transmission and storage, this subsection tested the algorithm’s robustness against clipping attacks. As shown in Figure 20a–c, 12.5%, 25%, and 50% of the Peppers cipher image was deleted, respectively.

The corresponding decrypted images are shown in Figure 20d–f. Despite the noise caused by information loss, the outline and main information of the original image can still be seen from the decrypted image. Therefore, our algorithm has the ability to resist data clipping attacks.

4.2.8. Chosen-Plaintext Attack

In an encryption system, the chosen-plaintext attack is highly threatening to the encryption system. Therefore, an image encryption system must have the ability to resist the analysis of the chosen-plaintext attack [51]. The result in Figure 21 indicates the proposed algorithm is reliable.

4.2.9. Randomness Test

The NIST test suite includes 15 tests, where different test items describe the difference between the sequence to be tested and the true random sequence from different perspectives [52]. The p-values of each test are calculated and if the p-value obtained after the experiment is greater than 0.01 in all experiments, the encryption result is credible.

Table 14. NIST test results.

Test	R		G		B
	p-Values	Pass/File	p-Values	Pass/File	p-Values	Pass/File
Frequency test	0.7563	Passed	0.1482	Passed	0.3377	Passed
Frequency test within a block	0.3825	Passed	0.3561	Passed	0.5212	Passed
Runs test	0.3332	Passed	0.5715	Passed	0.5068	Passed
Test for longest run of ones in a block	0.1126	Passed	0.1067	Passed	0.6612	Passed
Binary matrix rank test	0.2737	Passed	0.3323	Passed	0.1043	Passed
Discrete Fourier transform test	0.6057	Passed	0.7132	Passed	0.2341	Passed
Non-overlapping template matching test	0.3182	Passed	0.8317	Passed	0.3325	Passed
Overlapping template matching test	0.3073	Passed	0.7112	Passed	0.2956	Passed
Maurer’s “Universal Statistical” test	0.2496	Passed	0.3431	Passed	0.3014	Passed
Linear complexity test	0.5092	Passed	0.2321	Passed	0.5575	Passed
Serial test	0.2161	Passed	0.1250	Passed	0.4017	Passed
	0.0921	0.2161	0.1250	Passed	0.4017	Passed
Approximate entropy test	0.6561	Passed	0.6406	Passed	0.6249	Passed
Cumulative sums test	0.5276	Passed	0.5993	Passed	0.6331	Passed
Random excursions test	-	Passed	-	Passed	-	Passed
Random excursions variant test	-	Passed	-	Passed	-	Passed

,

Table 15. Random excursions test.

The Test	R		G		B
	p-Values	Pass/Fail	p-Values	Pass/Fail	p-Values	Pass/Fail
x = −4	0.2391	Passed	0.1673	Passed	0.3125	Passed
x = −3	0.8124	Passed	0.2419	Passed	0.4107	Passed
x = −2	0.2165	Passed	0.3718	Passed	0.0518	Passed
x = −1	0.0134	Passed	0.2152	Passed	0.3179	Passed
x = 1	0.4199	Passed	0.4179	Passed	0.0917	Passed
x = 2	0.2154	Passed	0.2007	Passed	0.1845	Passed
x = 3	0.1200	Passed	0.6120	Passed	0.3028	Passed
x = 4	0.0917	Passed	0.0234	Passed	0.5134	Passed

and

Table 16. Random excursions variant test.

The Test	R		G		B
	p-Values	Pass/Fail	p-Values	Pass/Fail	p-Values	Pass/Fail
x = −9	0.2167	Passed	0.2412	Passed	0.1341	Passed
x = −8	0.3214	Passed	0.0111	Passed	0.3219	Passed
x = −7	0.1033	Passed	0.3427	Passed	0.0713	Passed
x = −6	0.0023	Passed	0.0911	Passed	0.5217	Passed
x = −5	0.1892	Passed	0.2377	Passed	0.2513	Passed
x = −4	0.0912	Passed	0.1923	Passed	0.0712	Passed
x = −3	0.0035	Passed	0.1997	Passed	0.2613	Passed
x = −2	0.1734	Passed	0.1964	Passed	0.3107	Passed
x = −1	0.0531	Passed	0.0131	Passed	0.0125	Passed
x = 1	0.2921	Passed	0.2003	Passed	0.4003	Passed
x = 2	0.1793	Passed	0.1091	Passed	0.1026	Passed
x = 3	0.2234	Passed	0.0061	Passed	0.0041	Passed
x = 4	0.3112	Passed	0.0997	Passed	0.0157	Passed
x = 5	0.8917	Passed	0.4118	Passed	0.0673	Passed
x = 6	0.1187	Passed	0.5107	Passed	0.0155	Passed
x = 7	0.2562	Passed	0.1425	Passed	0.2517	Passed
x = 8	0.0911	Passed	0.2108	Passed	0.5718	Passed
x = 9	0.8134	Passed	0.3142	Passed	0.2542	Passed

show the NIST test results of the cipher image. It can be seen from the table that the proposed algorithm passed the NIST tests. The obtained cipher image has desirable randomness and is a qualified noisy image.

4.2.10. Computational Complexity and Encryption Time Analysis

The encryption efficiency analysis is divided into two parts: computational complexity analysis and encryption time analysis.

In our algorithm, the processing object is a color image. The algorithm processing time is mainly allocated to two major parts. The first part is the series of operations of the chaotic sequence. This part generates four sequences by iterating an improved SET chaotic system, whose maximum length is about m×n + 4v; thus, the complexity of the generation algorithm is O (m × n). The second part is base operations, including the dynamic block Zigzag transformation and the six-sided star diffusion. Its complexity is also O (48×m×n). In total, the computational complexity in this paper is O (48×m×n).

An efficient algorithm should encrypt images in the short time. The experiments in this subsection used a standard color test image of different sizes. To accurately measure the encryption time, the encryption program of the algorithm proposed in this paper was repeatedly run 100 times, and the average value was taken as the final result. The results comparising with other studies are shown in

Table 17. Algorithms’ encryption time (The bold part is the values of the proposed algorithm.).

Algorithms	The Size of a Color Image	Time (s)
Proposed	256 × 256	0.16
	512 × 512	0.32
	1024 × 1024	1.05
Ref. [30]	512 × 512	6.74
Ref. [25]	512 × 512	4.39
Ref. [46]	512 × 512	12.23
Ref. [47]	256 × 256	0.83
Ref. [48]	256 × 256	0.32
	512 × 512	1.81
Ref. [35]	512 × 512	1.00
Ref. [36]	512 × 512	2.08

.

5. Conclusions

To protect the content of color images, this paper proposes a new CIE algorithm. The specific advantages of our algorithm are reflected in the following aspects: (1) inspired by the standard Zigzag transformation, the proposed dynamic block Zigzag transformation can improve the horizontal correlation of ordinary Zigzag transformation and have obvious texture features; (2) the six-sided star model is designed to realize the bit operation, and high security is obtained; and (3) a new CIE algorithm is proposed and experimental results and analyses indicate that this algorithm is secure and efficient. Therefore, our algorithm can be applied to ensure image security in the fields of medical, military, etc.