Multiple-Image Encryption Scheme Based on an N-Dimensional Chaotic Modular Model and Overlapping Block Permutation–Diffusion Using Newly Defined Operation

Abstract

Some existing chaotic maps have the drawbacks of a narrow range of chaotic parameters and discontinuities, which may be inherited by new chaotic systems generated from them as seed maps. We propose a chaotic model that can generate N-dimensional chaotic systems to overcome the problem. By fixing the original parameters of the seed map in the chaotic range, we then introduce new parameters and use modular operations to widen the range of the parameters and increase the complexity. Simulation results show that the generated chaotic system has good chaotic dynamics. Based on this chaotic model, we propose a multiple-image encryption algorithm that is not limited by image type, number, and size. The resistance to plaintext attacks is enhanced by a permutation–diffusion algorithm based on overlapping blocks. We design a newly defined lookup table operation based on Latin squares with enhanced nonlinearity and randomness. By adjusting the overlapping block parameters and the number of Latin squares, users can design different encryption levels to balance encryption efficiency and encryption effectiveness. The experimental results show that the proposed image encryption algorithm can effectively encrypt multiple images, and all the evaluation indexes reach the expected value.

1. Introduction

In the era of information technology, multimedia carriers have experienced rapid development due to their rich means of expressing information. Digital images can directly convey visual information while having small storage sizes, making them one of the most commonly used means of information communication [1]. However, images can be susceptible to illegal attacks, leading to privacy breaches and property losses, both during transmission and storage. Encrypting images into unrecognizable noisy images is an effective means of protection. Access without the correct key will be unable to extract valid information from them. Various types of image encryption schemes have been proposed nowadays, such as chaotic systems, fractal theory [2,3], quantum computing [4,5], and optical methods [6,7].

Among the aforementioned technologies, chaotic systems have received increasing attention and are widely used in image encryption algorithms. Chaos is a pseudo-random dynamic complex phenomenon generated by deterministic nonlinear systems. Chaotic systems exhibit characteristics such as sensitivity to control parameters and initial conditions, pseudo-randomness, ergodicity, and unpredictability, making them highly suitable for cryptography. Chaotic systems are usually classified into one-dimensional (1D) and high-dimensional (HD) chaotic systems. One-dimensional chaotic systems have characteristics of simple structure, ease of implementation, and fast iteration speed. HD chaotic systems have characteristics of high complexity, multiple parameters, and long periods. Some encryption schemes directly utilize classical chaotic systems to complete the encryption. Kumar et al. [8] utilized the logistic map to generate chaotic sequences for key generation and then employed an improved shuffling technique to permute the image at the pixel level. Chen et al. [9] used the hyperchaotic Lorentz system to generate the key stream and proposed a nonsequential encryption mechanism, with improved permutation and diffusion methods as the core of encryption. However, some existing chaotic systems may exhibit defects such as a narrow and discontinuous range of chaotic parameters. Researchers have developed methods to improve chaotic systems to address these defects. Hua et al. [10] utilize sinusoidal functions as nonlinear transformations and apply them to the output of 1D chaotic maps to enhance complexity. Wang et al. [11] apply exponential and sinusoidal functions to both 1D and HD maps. However, due to the inherent inhomogeneity of the output from the nonlinear functions they use, the enhanced chaotic system also possesses the weakness of accumulating at the edges of the phase space. Modular arithmetic is used in chaotic systems because of its boundedness and uniform output. Hua et al. [12,13] improved the performance of the original chaotic maps by applying modular arithmetic to increase the chaotic complexity. However, this approach is limited to existing chaotic systems and does not create new ones. Zhou et al. [14] nonlinearly coupled two seed chaotic maps to improve the chaotic range using modular arithmetic, which is limited to 2D chaotic systems. Additionally, various chaotic maps have been employed as seed maps to generate new chaotic maps. Lin et al. [15] construct a crossed 2D hyperchaotic map using a nonlinear function and two chaotic maps with crossed structures. Sun [16] design a chaotic model based on cascaded modulation coupling. Gao [17] multiplies the outputs and employs nonlinear transformations to construct a 2D chaotic model. These methods typically retain the original parameters of the seed maps, which may inherit the disadvantages of the seed maps. Consequently, when one or more of the seed maps exist within a nonchaotic parameter space, the new chaotic system may also fail to enter the chaotic state.

Most image encryption algorithms employ a permutation–diffusion structure. The permutation phase involves rearranging the pixel positions in the image, making it challenging for attackers to identify the original pixel positions and the relationships between adjacent pixels. The diffusion phase propagates subtle changes throughout the entire image, introducing complex transformations to the pixel values. Diffusion enhances the complexity and unpredictability of the relationship between pixel values and encryption keys, improving resistance against plaintext attacks. Encryption can be performed at different levels, such as block level [18,19], pixel level [20,21], bit level [22,23], and DNA level [24]. Wang et al. [25] utilize a modified zigzag transform permutation at the pixel level, index sequence permutation, and dynamic encoding diffusion at the DNA level. Wei et al. [26] horizontally and vertically extend to a bit-level plane, exchanging row/column vectors for the permutation process. Bit-level and DNA-level permutations not only alter pixel positions but also pixel values, potentially requiring the generation of additional chaotic sequences. Hua et al. [27] partition the image into blocks equal to the block size during the disarrangement phase, evenly spreading pixels within blocks to other blocks. Wang et al. [28] divide the image into equal-sized blocks during the diffusion phase and select pixels from different sub-blocks using the Joseph problem, applying modular sum and XOR operations to change pixel values. Block-based operations can enhance encryption efficiency, but dividing the image into equal-sized blocks may introduce risks. The diffusion step transforms the plaintext image pixels using chaotic pixels to mask the pixels randomly. Common transformations include XOR operation, modular sum operation, and finite field operation. Wang et al. [29] combine XOR and modular sum operations to design four diffusion formulas, dynamically selected using chaotic sequences. To avoid information loss when the multiplier is 0, Xu et al. [30] utilize the multiplication table of GF(257) for diffusion operations instead of the multiplication table of GF(2⁸). Existing diffusion operations often exhibit monotonicity and vulnerability to attacks like differential attacks.

Image encryption technology finds applications in various fields such as personal, medical, industrial, and military, and the demand for image encryption is diverse. Firstly, different levels of confidentiality require different encryption requirements. Generally, as the security of encryption increases, the efficiency of encryption decreases. Therefore, finding a balance between encryption efficiency and security is crucial. The appropriate encryption scheme should be selected based on the desired level of confidentiality. Secondly, users may have diverse requirements in terms of the number, size, and type of images they need to encrypt. However, many existing image encryption schemes have limitations, such as only supporting a specific image type or images of the same size. Lastly, the design of encryption keys varies based on different needs. Users should have the option to use either a randomly generated key provided by the encryption scheme or a user-defined fixed key. In existing image encryption schemes, hash functions are often used to design keys to resist plaintext attacks, but this restricts user participation in the key design process.

To address the aforementioned issues, we propose a multidimensional chaos model based on modular arithmetic and a multiple-image encryption algorithm. In the proposed chaotic model, we fix the original parameters of the seed maps within the chaotic range, introduce new parameters through the nonlinear coupling of multiple outputs, and collapse the outputs using modular arithmetic. The chaotic model is not limited to some fixed number of dimensions, and it can generate chaotic systems of arbitrary dimensions. Users can design chaotic systems of varying dimensions based on the desired level of encryption confidentiality. We generate three chaotic systems using the model, with dimensions of two, three, and four, and validate their dynamics through simulation experiments, including phase diagrams, bifurcation diagrams, Lyapunov exponent diagrams, and sample entropy. The simulation results demonstrate that the generated chaotic systems possess a wide and continuous range of chaotic parameters, exhibiting good ergodicity and parameter sensitivity. In the proposed multiple-image encryption algorithm, we combine multiple images into a 1D array for encryption, making it adaptable to any image type, number, and size. For key design, we present two methods: the first method involves combining the hash value generated from plaintext images with random noise to generate the key, while the second method allows the user to set the key themselves. By incorporating chaotic systems, we achieve strong key sensitivity. We introduce a permutation–diffusion algorithm based on overlapping blocks, where permutation and diffusion mutually affect each other. This approach effectively reduces the correlation between adjacent pixels, significantly enhancing resistance against plaintext attacks. We provide adjustable parameters for block size and overlapping parts, enabling users to achieve different levels of security by adjusting these parameters. Additionally, we define a novel lookup table operation based on the Latin square. Through chaotic sequences, we generate several different Latin squares to reach dynamic operations in the form of row and column lookups. This enhances the nonlinearity and diversity of diffusion operations. We have conducted several simulation tests, and the experimental results demonstrate that the proposed image encryption algorithm effectively encrypts multiple images with strong security and efficiency.

The paper is organized as follows. In Section 2, a new chaotic model is introduced and three example chaotic systems are designed based on it. In Section 3, the performance of these chaotic systems is analyzed. In Section 4, the proposed new multi-image encryption algorithm is presented. In Section 5, the simulation results and the security of the algorithm are analyzed. In Section 6, conclusions about this thesis are given.

2. N-Dimensional Modular Chaotic Model

This section describes the construction of the N-dimensional coupled modular chaos model (ND-CMCM) and creates three different dimensional chaotic systems as examples by this model.

2.1. Construction of ND-CMCM

In order to improve the performance of chaotic maps, while users can construct suitable chaotic systems according to different needs, ND-CMCM is proposed in this paper.

Consider an N dimension of input x = (x₁, x₂, …x_N)^T. F_i(x_i, μ_i) (i = 1, 2, … N) are the N-selected 1D seed chaotic maps, where μ_i are the control parameters. The original control parameters of the seed chaotic maps are fixed at a number that can enter the chaotic state. Create new control parameters a_i (i = 1, 2, … N). We define the structure of ND-CMCM as Equation (1).

$$\left\{\begin{array}{l}{x}_{1,j+1}=\mathrm{mod}\left(a_1{F}_1\left(x_{1,j}\right)+a_1{f}_1\left(x_j\right)+a_2{f}_2\left(x_j\right)\cdots +a_N{f}_N\left(x_j\right),C\right)\\ x_{2,j+1}=\mathrm{mod}\left(a_2{F}_2\left(x_{2,j}\right)+a_1{f}_{N+1}\left(x_j\right)+a_2{f}_{N+2}\left(x_j\right)\cdots +a_N{f}_{2N}\left(x_j\right),C\right)\\ \begin{array}{ccc}& ⋮& \end{array}\\ x_{N,j+1}=\mathrm{mod}\left(a_N{F}_N\left(x_{N,j}\right)+a_1{f}_{N^2-N+1}\left(x_j\right)+a_2{f}_{N^2-N+2}\left(x_j\right)\cdots +a_N{f}_{N^2}\left(x_j\right),C\right)\end{array}\right.$$

(1)

where x_j is an N-dimensional vector which is the j-th state of the chaotic system iteration, f_i(x) (i = 1, 2, … N²) are nonlinear functions that couple multidimensional outputs, mod is the modular arithmetic, and C is the modulus coefficient. In the general case, the model can be simplified to Equation (2).

$$\left\{\begin{array}{l}{x}_{1,j+1}=\mathrm{mod}\left(a_1{F}_1\left(x_{1,j}\right)+a_2{f}_1\left(x_j\right),C\right)\\ x_{2,j+1}=\mathrm{mod}\left(a_2{F}_2\left(x_{2,j}\right)+a_3{f}_2\left(x_j\right),C\right)\\ \begin{array}{ccc}& ⋮& \end{array}\\ x_{N-1,j+1}=\mathrm{mod}\left(a_{N-1}{F}_{N-1}\left(x_{N-1,j}\right)+a_N{f}_{N-1}\left(x_j\right),C\right)\\ x_{N,j+1}=\mathrm{mod}\left(a_N{F}_N\left(x_{N,j}\right)+a_1{f}_N\left(x_j\right),C\right)\end{array}\right.$$

(2)

The chaotic system designed by this model has a more complex dynamical behavior than the seed chaotic maps. The modular arithmetic can keep the output in a finite range, which not only allows a_i to be set to any larger value but also increases the complexity of the chaotic system. Compared to other bounded functions, modular operations can make the output more uniform in phase space. The modulus coefficient C can be arbitrarily set to a relatively small number compared to the parameter a_i, which increases the diversity of the system. By utilizing various 1D chaotic systems and nonlinear functions, ND-CMCM can generate multiple chaotic systems, thus simplifying the design process and giving the user the freedom to design the desired chaotic system.

2.2. Examples of the Proposed Chaotic Model

In order to verify the excellent performance of ND-CMCM, we choose some classical 1D chaotic maps and some 1D chaotic maps from recent literature as examples, which are combined into three different dimensions of chaotic maps.

2.2.1. 2D Logistic–PWLCM Coupled Modular Map

The logistic map [31] is one of the most classical and commonly used chaotic maps. It is defined as Equation (3).

$$x_{n+1}=\mu x_n\left(1-x_n\right)$$

(3)

where x_n ∈ (0, 1), μ ∈ [0, 4] is a control parameter. When the parameter μ is in the interval (3.57, 4], the logistic map enters the chaotic state.

The piece-wise linear chaotic map (PWLCM) [32] is widely used for its simple structure and good traversability. PWLCM is defined as Equation (4).

$$x_{n+1}=T\left(x_n,p\right)=\left\{\begin{array}{cc}{x}_n/p& 0\le x_i<p\\ (x_n-p)/(0.5-p)& p\le x_i<0.5\\ T\left(1-x_n,p\right)& 0.5\le x_i<p\end{array}\right.$$

(4)

where x_n ∈ (0, 1), p ∈ (0, 0.5) is the control parameter and the map is in the chaotic state within this range.

The 2D logistic–PWLCM coupled modular map (2D-LPCMM) is obtained by combining the logistic map and PWLCM, with the parameter μ of the logistic map fixed at 4 and the parameter p of the PWLCM fixed at 0.3. The expression is as Equation (5).

$$\left\{\begin{array}{l}{x}_{n+1}=\mathrm{mod}\left(4a{x}_n\left(1-x_n\right)+b{y}_n\left(1-x_n\right),1\right)\\ \left\{\begin{array}{cc}{y}_{n+1}=\mathrm{mod}\left(b{y}_n/0.3+a{x}_n\left(1-y_n\right),1\right)& 0\le y_n<0.3\\ y_{n+1}=\mathrm{mod}\left(b\left(y_n-0.3\right)/0.2+a{x}_n\left(1-y_n\right),1\right)& 0.3\le y_n<0.5\\ y_{n+1}=\mathrm{mod}\left(b\left(0.7-y_n\right)/0.2+a{x}_n\left(1-y_n\right),1\right)& 0.5\le y_n<0.7\\ y_{n+1}=\mathrm{mod}\left(b\left(1-y_n\right)/0.3+a{x}_n\left(1-y_n\right),1\right)& 0.7\le y_n<1\end{array}\right.\end{array}\right.$$

(5)

where x_n ∈ (0, 1), a and b are the two newly created control parameters. Since the mod is a bounded function that collapses the output, a and b can be very large values. In this paper, we investigate the properties of 2D-LPCMM for a, b in the range [1, 1000].

2.2.2. 3D Cubic–Fraction–IST Coupled Modular Map

The form of the cubic map [33] can be expressed by Equation (6).

$$x_{n+1}=\rho x_n\left(1-x_n^2\right)$$

(6)

where x_n ∈ (0, 1), ρ ∈ [0, 3] is a control parameter. When the parameter ρ is in the interval (2.59,3], the cubic map exhibits complex behavior.

The fraction map [34] was discovered in the study of evolutionary algorithms. This map is more complex than the logistic map and its expression is Equation (7).

$$x_{n+1}=\frac{1}{x^2+0.1}-p{x}_n$$

(7)

where x_n ∈ [−10.0025, 10.0025], p ∈ [−0.999, 0.999] is a control parameter. In the interval p ∈ [0.699, 0.1510] ∪ [0.2470, 0.3590] ∪ [0.3770, 0.5170] ∪ [0.5680, 0.6280] ∪ [0.6310, 0.6770], the system is chaotic.

The improved sine–tangent map (IST map) [35] is derived from the sine map, the tangent function, and the first class of Chebyshev polynomials. It is defined as follows.

$$x_{n+1}=\sin \left(\alpha \tan \left(3x_n{}^2-1.5\right)\right)$$

(8)

where x_n ∈ [−1, 1], α ∈ (0, 8] is a control parameter and in this interval the map is chaotic.

The 3D cubic–fraction–IST coupled modular map (3D-CFICMM) is obtained by combining the cubic map, fraction map, and IST map, with the parameter ρ of the cubic map fixed at 3, the parameter p of the fraction map fixed at 0.5, and the parameter α of the IST fixed at 7. The expression is as Equation (9).

$$\left\{\begin{array}{l}{x}_{n+1}=\mathrm{mod}\left(3a{x}_n(1-x_n{}^2)+b{y}_n{z}_n\cos (x_n),2\right)\\ y_{n+1}=\mathrm{mod}\left(b/\left(y_n{}^2+0.1\right)-0.5b{y}_n+c{x}_n{z}_n\cos (y_n),2\right)\\ z_{n+1}=\mathrm{mod}\left(c\sin \left(7\tan \left(3z_n{}^2-1.5\right)\right)+a{x}_n{y}_n\cos (z_n),2\right)\end{array}\right.$$

(9)

where x_n ∈ (0, 2), a, b, and c are the three newly created control parameters. a, b, and c can be very large values. In this paper, we investigate the properties of 3D-CFICMM for a, b, c ∈ [1, 1000].

2.2.3. 4D ICMIC–ICMIC–1DSP–1DCP Coupled Modular Map

The iterative chaotic map with infinite collapses (ICMIC) [36] is also a commonly used 1D chaotic system and is often used as a seed map to construct new functions. The formal definition of the ICMIC is given by Equation (10).

$$x_{n+1}=\sin \left(\frac{\beta }{x_n}\right)$$

(10)

where x_n ∈ [−1, 1], β ∈ (0, ∞) is a control parameter. This map has many periodic windows that lead to discontinuities in the chaotic range. For example, there are large periodic windows for the parameter β ∈ (0, 1.8197) ∪ (4.1411, 4.8143) ∪ (7.5073, 7.9163). There are also many narrow period windows such as β ∈ (2.5584, 2.5686).

The 1D sine powered chaotic map (1DSP) [37] was designed inspired by the sine map and the sine map was used to avoid exponential growth of the output. The 1DSP is defined as Equation (11).

$$x_{n+1}={\left(x_n\left(\alpha +1\right)\right)}^{\sin \left(\beta \pi +x_i\right)}$$

(11)

where x_n ∈ [0, 1], α ∈ (0, ∞) and β ∈ [0, 1] are two control parameters. For α ∈ (2, ∞) and β ∈ [0.011, 0.46], 1DSP exhibits continuous chaotic behavior.

The 1D cosine polynomial (1DCP) [38] is designed as a simple structure with highly chaotic behavior. The 1DCP is defined as Equation (12).

$$x_{n+1}=\cos \left(\mu \left(x_n^3+x_n\right)\right)$$

(12)

where x_n ∈ [−1, 1], μ ∈ (−∞, ∞) is a control parameter. When the parameter μ is small, there is a narrow period window.

The 4D ICMIC–ICMIC–1DSP–1DCP coupled modular map (4D-IISCCMM) is obtained by combining the ICMIC c map, 1DSP, and 1DCP, with the parameter β of the ICMIC map fixed at 6 and 8, the parameter α and β of the 1DSP fixed at 4.4926 and 0.3306, and the parameter μ of the 1DCP fixed at 1000. ICMIC is used twice, implying that ND-CMCM does not necessarily require different seed chaotic maps. The expression is as Equation (13).

$$\left\{\begin{array}{l}{x}_{n+1}=\mathrm{mod}\left(a\sin \left(6/x_n\right)+b\left(z_n{w}_n+\sin \left(x_n{y}_n\right)\right),3\right)\\ y_{n+1}=\mathrm{mod}\left(b\sin \left(8/y_n\right)+c\left(w_n{x}_n+\sin \left(y_n{z}_n\right)\right),3\right)\\ z_{n+1}=\mathrm{mod}\left(c{z}_n{\left(4.4926+1\right)}^{\sin \left(0.3306\pi +z_n\right)}+d\left(x_n{y}_n+\sin \left(z_n{w}_n\right)\right),3\right)\\ w_{n+1}=\mathrm{mod}\left(d\cos \left(1000\left(w_n^3+w_n\right)\right)+a\left(y_n{z}_n+\sin \left(w_n{x}_n\right)\right),3\right)\end{array}\right.$$

(13)

where x_n ∈ (0, 3), a, b, c, and d are the four newly created control parameters. a, b, c, and d can be very large values. In this paper, we investigate the properties of 4D-IISCCMM for a, b, c, d ∈ [1, 1000].

The 3D-CFICMM and 4D-IISCCMM suffer from computational overload. We cite them as examples to demonstrate the generation of chaotic systems with different dimensions, using various nonlinear function coupling methods and modulus coefficients. Therefore, these two chaotic systems are designed without significant consideration of efficiency. The computational workload of the generated chaotic system is related to the seed chaotic maps and the nonlinear function it employs, both of which are determined by the designer. Users have the freedom to design chaotic systems according to their individual needs and preferences.

3. Performance Analysis of New Systems

In this section, we conduct a quantitative analysis of three chaotic systems generated by ND-CMCM to verify their complexity, ergodicity, and sensitivity to parameters. The evaluation encompasses three aspects: bifurcation and phase diagrams, Lyapunov exponents, and sample entropy.

3.1. Bifurcation Diagram and Phase Diagram

The dynamical behavior of a chaotic system can be revealed by using bifurcation diagrams and phase diagrams, which are visualizations of the trajectory and ergodicity of the chaotic system. The bifurcation diagram shows the distribution of the output of a chaotic system in the phase space over a specific range of parameters. The phase diagram draws the values of two or more state variables against each other, representing the intrinsic relationship of the state variables. Figure 1 and Figure 2 show the bifurcation and phase diagrams of 2D-LPCMM, 3D-CFICMM, and 4D-IISCCMM, respectively. The 3D and 4D systems require multiple figures to show all the bifurcation and phase diagrams because of the high dimensionality and many parameters. Since the contents of these figures are similar, only some of them are shown. From the figures, we can see that the chaotic trajectory spreads over the whole phase space. There is no period window over a large range of parameters. The chaotic output values are not clustered at the edges of the phase space and are extremely uniformly distributed.

3.2. Lyapunov Exponent

The Lyapunov exponent (LE) is an index for the quantitative evaluation of chaotic systems. It reflects the sensitivity of a chaotic system to the initial conditions and enables determination of whether the chaotic system is in a chaotic or periodic state with specific parameters. The number of Lyapunov exponents of a chaotic system is equal to the number of dimensions of its phase space. One positive Lyapunov exponent indicates that the system exhibits chaotic behavior, and more than one positive Lyapunov exponent indicates that the system exhibits hyperchaotic behavior. The spectrum of Lyapunov exponents is shown in Figure 3. All three systems have positive Lyapunov exponents equal to the dimensionality in all parameter ranges. To visualize the superiority of our proposed system, the maximum Lyapunov exponent (MLE) spectrum of the proposed systems and the seed maps are plotted in Figure 4. The MLE spectrums of chaotic systems are scaled to the figure with horizontal coordinates in the range a ∈ [1,1000]. For example, the parameter range of the logistic map is μ ∈ [μ_min,μ_max] = [0,4], and the value of μ as the horizontal coordinate a varies can be obtained by Equation (14). The other parameter of 2D-LPCMM was set to b = 500. The other parameters of 3D-CFICMM were set to b = 500 and c = 500. The other parameters of 4D-IISCCMM were set to b = 500, c = 500, and d = 500. The other parameter of 1DSP was set to α = 4.4926.

$$\mu =\frac{a-1}{\left(1000-1\right)}\times \left({\mu }_{\max }-{\mu }_{\min }\right)+{\mu }_{\min }$$

(14)

3.3. Sample Entropy

Sample entropy (SE) is a measure that quantifies the level of regularity or complexity observed in a time series, allowing us to assess the predictability and unpredictability of the resulting chaotic output. Consider a time series of the form {x₁, x₂, …, x_N}. Set the value of the parameter m, which means the length of the template vector. For each template vector X_m(i), defined as {x_i, x_i+1, …, x_i+m−1}, we calculate the Chebyshev distance between each pair of template vectors and denote it as d[X_m(i), X_m(j)]. Set another parameter r, which means tolerance threshold. The number of vectors with Chebyshev distances below the threshold r is calculated and denoted as B. The number of vectors with Chebyshev distances below the threshold r is calculated for each pair of template vectors after increasing the length of the template by 1, i.e., m + 1, and denoted as A. SE can be defined as

$$SE\left(m,r,N\right)=-\log \frac{A}{B}$$

(15)

A lower SE value indicates a higher regularity in the chaotic sequence, with more certainty and order. On the contrary, higher SE values indicate higher complexity and irregularity. The parameters m and r affect the magnitude of the calculated SE, and in this paper we set them to 2 and 0.2, respectively. Figure 5 plots part of the SE of 2D-LPCMM, 3D-CFICMM, and 4D-IISCCMM, and it can be seen that in all parameter ranges SE is greater than 2. Figure 6 shows a comparison of the SE of the proposed systems and the seed maps. The other parameter settings for the multiparameter chaotic systems are the same as in Figure 4.

4. Proposed Encryption Algorithm

Chaotic systems are generally used as pseudo-random sequence generators in image encryption algorithms. The performance of the chaotic system affects the effectiveness of image encryption. Our proposed chaotic system has excellent sensitivity to parameters, complexity, and unpredictability, while the chaotic trajectory is very uniform and covers the whole phase space. The chaotic system generated by ND-CMCM is well suited for application in image encryption. Based on this, we have developed an algorithm that can be used regardless of the number, type, and size of images. The flowchart of this algorithm is shown in Figure 7.

4.1. Overlapping Block

The overlapping block is designed to increase the complexity of image encryption while designing adjustable parameters to balance the encryption time and encryption effect. The length of the overlapping blocks is random and generated by the chaotic sequence. We designed the parameters B_min and B_max, which are the minimum and maximum values of the random length of the overlapping blocks, respectively, and they determine the percentage of overlapping blocks.

The method of overlapping block partition is shown in Figure 8. First, determine the values of B_min and B_max. The smaller the B_min and the larger the B_max, the longer the encryption time and the better the encryption effect. Second, calculate the number of overlapping blocks:

$$B_n=\mathrm{ceil}\left(B_{len}/B_{\min }\right)$$

(16)

where B_len is the length of the 1D array being partitioned and ceil is an upward rounding function. Finally, the random length of overlapping blocks S(i) (i = 1, 2, …, B_n) is generated by chaotic sequences. The overlapping parts are repeatedly involved in the permutation–diffusion process. For a detailed algorithm on overlapping block permutation–diffusion, please refer to Section 4.3.

4.2. Newly Defined Operations Based on Latin Squares and Lookup Table

A Latin square is a mathematical structure that is a square array of n × n. In this n × n square, there are n different elements, and each different element appears only once in the same row or column. Elements can be numbers, letters, symbols, etc. We use Algorithm 1 [39] to generate a n-th-order Latin squares with elements of positive integers from 0 to n.

A lookup table operation is a way to quickly access values based on data in a table or similar array. We define a new operation using the Latin square as a lookup table. Consider a Latin square L of order n + 1 with constituent elements 0, 1, …, n. The lookup table operation function based on the Latin square (LL) is defined as

$$k=\mathrm{LL}\left(i,j,L\right)=L[i+1,j+1]$$

(17)

where LL is the name of the function, L[i,j] represents taking out the elements of the i-th row and j-th column of matrix L. We take an example of a lookup table based on the four-order Latin square L₀ to illustrate the operation specifically, as shown in Figure 9a, where the white squares are the Latin squares L₀, the gray column squares are the i in Equation (17), and the gray row squares are the j. It is easy to know that performing an addition operation on 2 and 3 yields 5 and performing a bitxor operation on 2 and 3 yields 1. However, when we perform the L₀-based LL operation on 2 and 3, i.e., LL(2,3,L₀), the result of the operation is the number in row 3, column 4 of L₀, i.e., L₀[2 + 1,3 + 1] = L₀[3,4] = 1. In order to obtain i through k and j, we need to perform an reverse LL operation. Specifically, we obtain the reverse Latin square through Equation (18), and then we perform the LL operation on k and j. The algorithm for generating the reverse Latin square is shown in Algorithm 2, and the reverse Latin square L₀′ of L₀ is shown in Figure 9b.

$$i=\mathrm{LL}\left(k,j,L\prime \right)=L\prime [\left(L[i+1,j+1]+1,j+1\right)$$

(18)

More examples of LL operations are shown below.

$$\mathrm{LL}\left(1,2,L_0\right)=L_0[2,3]=0$$

(19)

$$\mathrm{LL}\left(0,2,L_0\prime \right)=L_0\prime [1,3]=1$$

(20)

$$\mathrm{LL}\left(3,1,L_0\right)=L_0[4,2]=2$$

(21)

$$\mathrm{LL}\left(2,1,L_0\prime \right)=L_0\prime [3,2]=3$$

(22)

LL is an operation with both input and output in the range of integers 0 to n. It has more complex nonlinear properties than additive operations, XOR operations, and Galois field, and it is suitable to be used in confusion diffusion of image encryption. In order to visually compare the differences between the proposed operation and other different operations, we generated three Latin squares L₁, L₂, and L₃ and drew the results of their operations. Figure 10 shows a discrete plot of the results of the different operations, where x and y are integers in the range 0 to 255 and the blue color represents the points in the 3D plot determined by x, y and the results obtained from x and y. It can be seen that our proposed operation is more complex compared to other operations. In addition, different Latin squares can give different results, so the operations are diverse.

Algorithm 1 Pseudo-code for generating Latin squares
Input: chaotic sequences Q1 and Q2 of length n  Output: nth order Latin square L
1:	[~,I1] = sort(Q1);
2:	[~,I2] = sort(Q2);
3:	I1 = I1 − 1;
4:	for  i = 0 to n − 1
5:	L(i + 1,:) = circshift(I1,I2(i + 1));
6:	end for

Algorithm 2 Pseudo-code for generating reverse Latin squares
Input: nth Latin square L Output:nth reverse Latin square L’
1:	for i = 0 to n − 1
2:	for j = 0 to n − 1
3:	L’(L(i + 1,j + 1) + 1,j + 1) = i;
4:	end for
5:	end for

4.3. Encryption Process

The proposed encryption algorithm provides parameters that can balance the encryption time and efficiency. The parameters we provide are B_min, B_max, and L_num; the first two are used to determine the length of the random overlapping block and the latter determines the number of Latin squares used for the LL operation.

4.3.1. Generation of Secret Key and Chaotic Sequences

The proposed encryption algorithm offers two methods for setting the key, which is the parameter of the chaotic system. The first method involves dividing it into an internal key and an external key. The internal key is generated using the hash function, while the external key is generated by random noise. By combining the sensitivity of the hash function to the plaintext and the sensitivity of the chaotic system to the parameters, even a small change in the plaintext image will lead to a completely different encryption result. The external key is derived from random noise, increasing security and making the encryption result different each time. The second method allows users to set their own keys. The diffusion phase in the proposed encryption algorithm can propagate small changes in the plaintext image to the whole image, and in combination with the newly defined nonlinear operations, the encryption becomes unpredictable. In this paper, we use 2D-LPCMM for encryption.

The steps to generate the chaotic sequences are as follows.

Step 1: Input n images and record their sizes.

Step 2: Expand the input images into a 1D array in column-major order and concatenate them horizontally, denoted as P. Calculate the length of P, denoted as B_len. Calculate B_n according to Equation (16).

Step 3: In this step, the key is generated by the hash function. It can be skipped if the key is customized. The hash function we use is SHA-512. Input P into the hash function to obtain a binary number H of length 512. Convert H to decimal and divide it into 32 parts named k₁, k₂, k₃, …, k₃₂. H and k_i are calculated as follows.

$$H=\mathrm{hash}\left(P,\prime \mathrm{SHA}-512\prime \right)$$

(23)

$$\begin{array}{cc}{k}_i=\mathrm{bin}2\mathrm{dec}\left(H(16\left(i-1\right)+1:16i\right),& i=1,2,\cdots 32\end{array}$$

(24)

Obtain the control and initial parameters of the chaotic system from the following equation.

$$\left\{\begin{array}{l}a=\mathrm{sum}\left(k_1,k_2,k_3,k_4\right)\times \mathrm{sum}\left(k_5,k_6,k_7,k_8\right)/2^{36}\times 1000+5\\ b=\mathrm{sum}\left(k_9,k_{10},k_{11},k_{12}\right)\times \mathrm{sum}\left(k_{13},k_{14},k_{15},k_{16}\right)/2^{36}\times 1000+5\\ x_0=\mathrm{mod}\left(\mathrm{sum}\left(k_{17},k_{18},k_{19},k_{20}\right)/\mathrm{sum}\left(k_{21},k_{22},k_{23},k_{24}\right)+\mathrm{rand}\left(1\right),1\right)\\ y_0=\mathrm{mod}\left(\mathrm{sum}\left(k_{25},k_{26},k_{27},k_{28}\right)/\mathrm{sum}\left(k_{29},k_{30},k_{31},k_{32}\right)+\mathrm{rand}\left(1\right),1\right)\\ t=\mathrm{mod}\left(\mathrm{ceil}\left(mean\left(k_1,k_2,\dots ,k_{32}\right)\right),1000\right)+1000\end{array}\right.$$

(25)

where a and b are the control parameters, x₀ and y₀ are the initial parameters of the chaotic system, t denotes the first t values of the chaotic sequence discarded to prevent transient effects, and rand is a function that generates uniform random noise.

Step 4: Substitute a, b, x₀, y₀ into 2D-LPCMM for iteration, and after discarding the first t values, chaotic sequence CS₀ of length 512 × L_num and chaotic sequences CS₁, CS₂, CS₃, CS₄, CS₅, CS₆, CS₇, CS₈ of length B_n are generated. Each overlapping block length S₁ and S₂ can be calculated by the following equation.

$$S_1=\mathrm{mod}\left(\mathrm{ceil}\left(C{S}_1\times {10}^{10}\right),B_{\max }-B_{\min }\right)+B_{\min }$$

(26)

$$S_2=\mathrm{mod}\left(\mathrm{ceil}\left(C{S}_2\times {10}^{10}\right),B_{\max }-B_{\min }\right)+B_{\min }$$

(27)

$$B_{S1}=\mathrm{sum}\left(S_1\right)$$

(28)

$$B_{S2}=\mathrm{sum}\left(S_2\right)$$

(29)

where B_s1 and B_s2 are the sum of the lengths of all overlapping blocks. Then, generate the chaotic sequences CS₉ and CS₁₀ of length B_S1, CS₁₁ of length B_S2.

4.3.2. Overlapping Block Permutation–Diffusion

Permutation and diffusion are simultaneous and are divided into forward permutation–diffusion and backward diffusion. The permutation can scramble the values within a block into the entire 1D array. The diffusion includes inter-block diffusion, intra-block diffusion, and mask diffusion.

To facilitate understanding, we first present an example before summarizing the encryption process, as shown in Figure 11. In this example, the parameter B_min is set to 4, B_max is set to 8, and L_num is set to 2.

Step 1: Generate L_num (2) Latin squares denoted L{1} and L{2}, as shown in Figure 12.

Step 2: Input two images of size 3 × 3 and expand them column-wise into a 1D array P of length 18.

Step 3: Divide P into 5 (ceil(18/4), see Equation (16)) overlapping blocks. The initial position of each overlapping block in the figure is indicated by the black dashed line. The length of each block is between B_min (4) and B_max (8) and is determined by the chaotic sequence.

Step 4: Choose the first overlapping block, framed by the black line, whose length is 7. Record the index of the first overlapping block as A, A = [1, 2, 3, 4, 5, 6, 7].

Step 5: Generate 7 random numbers E ranging from 1 to 18, E = [17, 13, 18, 15, 10, 3, 13].

Step 6: Process arrays A and E. As there are many duplicate numbers in A and E, this may cause data loss. Combine E and A into a temporary array Temp = [17, 13, 18, 15, 10, 3, 13, 1, 2, 3, 4, 5, 6, 7], remove the duplicates, and split it into two arrays E₁ = [17, 13, 18, 15, 10, 3] and A₁ = [1, 2, 4, 5, 6, 7]. The process is represented by Algorithm 3.

Step 7: Swap the pixel of P indexed by E₁ and A₁, shown in the figure with black bi-directional arrows. For example, the 17th pixel (7) and the first pixel (0) swap positions.

Step 8: Perform the L{2}-based LL operation on the first two pixels of the first overlapping block and the first two pixels of the last overlapping block. This operation is indicated by orange arrows in the figure. For example, the first pixel of the first block is 7, and the first pixel of the last block is 0. Operate on them to obtain LL(7,0,L{2}) = 7. Similarly, the second pixel of these two blocks is operated on to obtain LL(3,3,L{2}) = 1.

Step 9: Perform the L{1}-based LL operation on each pixel of the first overlapping block and its previous pixel. This operation is indicated by purple arrows in the figure. For example, the first pixel of the first block is 7, and the last pixel of the last block is 3. Operating on them obtains LL(7,3,L{1}) = 1. Similarly, the second pixel of the first block is 1, and now the first pixel of the first block is 1. Operating on them obtains LL(1,1,L{1}) = 4.

Step 10: Generate 7 random numbers D ranging from 0 to 8, D = [5, 8, 8, 1, 3, 6, 2].

Step 11: Perform the L{1}-based LL operation on each pixel of the first overlapping block and numbers in array D. This operation is indicated by gray arrows in the figure. For example, the first pixel of the first overlapping block is 1 and the first number in D is 5. Operating on them obtains LL(1,5,L{1}) = 5. The second pixel of the first overlapping block is 4 and the second number in D is 8. Operating on them obtains LL(4,8,L{1}) = 6.

Step 12: The first B_min (4) blocks of the first overlapping block are no longer involved in the subsequent permutations. This means that the index of the 1D array P starts at the first pixel of the second overlapping block.

Step 13: Choose the second overlapping block, framed by the black line, whose length is 8. Record the index of the first overlapping block as A, A = [1, 2, 3, 4, 5, 6, 7, 8].

Step 14: Repeat step 5 to step 11. The generated random arrays E and D are E = [7, 13, 2, 3, 6, 8, 6, 7], D = [8, 1, 6, 5, 0, 5, 5, 4]. The Latin squares used in steps 8, 9, and 11 are L{1}, L{2}, and L{2}, respectively.

Step 15: Recover the encrypted 1D array P into two images of size 3 × 3.

Algorithm 3 Pseudo-code for index processing
Input: E, A Output: E1, A1
1:	Temp = [E A];
2:	Temp = unique(Temp,’stable’);
3:	Stemp = length(Temp);
4:	if  mod(Stemp,2) = 1
5:	Temp(end) = [];
6:	Stemp = Stemp − 1;
7:	end if
8:	E1 = Temp(1: Stemp/2);
9:	A1 =Temp(Stemp/2 + 1:end);

The detailed encryption process is summarized as follows.

Step 1: Confirm the parameters B_min, B_max, and L_num. B_min and B_max determine the length range of the overlapping blocks, and L_num determines the number of Latin squares to be generated.

Step 2: Generate L_num Latin squares. Divide CS₀ into L_num groups, each group has 2 arrays of length 256, and generate L_num Latin squares L{i} (i = 1, 2, …, L_num) by Algorithm 1.

Step 3: Obtain the random number used to select Latin squares L₁, L₂, and L₃ through the chaotic sequences CS₃, CS₄, CS₅.

Step 4: Input n images and record their sizes. Expand the input images into a 1D array in column-major order and concatenate them horizontally, denoted as P. Calculate the length of P, denoted as B_len.

Step 5: Divide P into B_n overlapping blocks, where B_n = ceil(B_len/B_min).

Step 6: Select the i-th (i = 1, 2, …, B_n) overlapping block. Denote the length of the block as S, where S = S₁(i) and S₁ is obtained from Equation (26).

Step 7: Denote the length of the array in which the overlapping blocks are to be arranged as P_len, where P_len= B_len − (i − 1) × B_min. When P_len is less than S₁(i), S = P_len.

Step 8: Generate S random numbers E ranging from 1 to P_len through the chaotic sequences CS₉, where E = mod(ceil(CS₉ × 10¹⁴),P_len) + 1.

Step 9: Permutation. Let A be the array from 1 to S₁(i). Obtain E₁ and A₁ by inputting E and A into Algorithm 3. Swap the pixels of P indexed by E₁ and A₁.

Step 10: Inter-block diffusion. Perform the LL operation based on the L₁-th Latin square L{L₁} for the first B_min pixels of the i-th overlapping block and the first B_min pixels of the i − 1-th overlapping block.

Step 11: Intra-block diffusion. Perform the LL operation based on the L₂-th Latin square L{L₂} for the k-th (k = 1, 2,…, S) pixel and the k − 1-th pixel of the i-th overlapping block.

Step 12: Generate S random numbers D ranging from 0 to 255 through the chaotic sequences CS₁₀, where D = mod(ceil(CS₁₀ × 10¹⁴),256).

Step 13: Mask diffusion. Perform LL operations based on the L₃-th Latin square L{L₃} for the whole i-th overlapping block and D.

Step 14: Forward permutation–diffusion. Add 1 to i (i = i + 1) and loop step 4 to step 11 until i = B_n. The specific pseudo-code is shown in Algorithm 4.

Step 15: Flip the array P from left to right P = fliplr(P).

Step 16: Select the i-th (i = 1, 2, …, B_n) overlapping block. Denote the length of the block as S, where S = S₂(i) and S₂ is obtained from Equation (27).

Step 17: Backward diffusion. Add 1 to i (i = i + 1) and loop step 8 to step 11 until i = B_n.

Step 18: Recover the encrypted 1D array P into multiple images based on the sizes of the recorded original images.

Algorithm 4 Pseudo-code for forward permutation–diffusion
Input: P, Blen, Bmin, S1, CS3, CS4, CS5, CS9, CS10, CS13, Output: P
1:	Ct = 1; Plen = Blen;
2:	for i = 1 to Bn
3:	if Plen < S1(i)
4:	S = Plen;
5:	end if
6:	L1 = mod(ceil(CS3(i) × 1014),Lnum) + 1; L2 = mod(ceil(CS4(i) × 1014),Lnum) + 1;
7:	L3 = mod(ceil(CS5(i) × 1014),Lnum) + 1; E = mod(ceil(CS9(Ct:Ct + S − 1) × 1014),Plen) + 1;
8:	D = mod(ceil(CS10(Ct:Ct + S − 1) × 1014),256); Ct = Ct + S;
9:	A = 1 to S;
10:	[E1,A1] = Algorithm 2(E,A); E1 =E1 + (i − 1) × Bmin; A1 =A1 + (i − 1) × Bmin;
11:	P(E1)⇔P(A1)
12:	if i > 1
13:	if Plen > Bmin
14:	P((i − 1) × Bmin + 1:i × Bmin) = LL(P((i − 1) × Bmin + 1:i × Bmin),P((i − 2) × Bmin + 1:(i − 1) × Bmin),L{L1});
15:	else
16:	P((i − 1) × Bmin + 1:end)= LL(P((i − 1) × Bmin + 1:end),P((i − 2) × Bmin + 1:(i − 1) × Bmin),L{L1});
17:	end if
18:	for  k = 1 to S
19:	P((i − 1) × Bmin + k) = LL(P((i − 1) × Bmin + k),P((i − 1) × Bmin + k − 1),L{L2});
20:	end for
21:	else
22:	P(1:Blen − ((Bn − 1) × Bmin)) = LL(P(1:Blen − ((Bn − 1) × Bmin)),P((Bn − 1) × Bmin + 1:end), L{L1});
23:	P(1) = LL(P(1),P(Bn),L{L2});
24:	for  k = 2 to S
25:	P(k) = LL(P(k),P(k − 1),L{L2});
26:	end for
27:	end if
28:	P((i − 1) × Bmin + 1:(i − 1) × Bmin + S) = LL(P((i − 1) × Bmin + 1:(i − 1) × Bmin + S),D,L{L3});
29:	Plen = Plen − Bmin;
30:	end for

4.4. Decryption Process

The decryption process is the inversion of the encryption. The specific decryption process is as follows.

Step 1: Record the size of the ciphertext images and expand them into a 1D array in column-major order, concatenate them horizontally to obtain a 1D array P. Calculate the length of P, denoted as B_len. Calculate B_n according to Equation (16).

Step 2: Generate chaotic sequences from keys.

Step 3: Generate the Latin squares used in the encryption process and input them into Algorithm 2 to obtain the reverse Latin squares.

Step 4: Perform the reverse operation of overlapping block permutation–diffusion to obtain the decrypted 1D array P, where the Latin square used is changed to the reverse Latin square.

Step 5: Recover the decrypted 1D array P into multiple images based on the sizes of the recorded original images.

5. Experimental Results and Security Analysis

In this section, to test the performance of the image encryption algorithm, we encrypt multiple color and grayscale images of different sizes at the same time. These tests analyze the effectiveness of the proposed algorithm from various aspects. The test images were obtained from the USC-SIPI Image Database (https://sipi.usc.edu/database/, accessed on 13 July 2023). The test images we used include 256 × 256 × 3 4.1.01.tiff, 512 × 512 × 1 5.2.10.tiff, 512 × 512 × 3 4.2.05.tiff, and 1024 × 1024 × 1 5.3.01.tiff. In Section 4.1, we set parameters that can balance encryption time and encryption effect. We used three different groups of parameters to set up three different levels of encryption. The first group is B_min = ceil(power(B_len,1/2)) × 3, B_max = 1.5 × B_min, L_num = 20. The second group is B_min = ceil(power(B_len/3,1/2)), B_max = 2 × B_min, L_num = 50. The third group is B_min = ceil(power(B_len,1/3)), B_max = 4 × B_min, L_num = 100. To accommodate different numbers of pixels, B_min and B_max are related to the total number of image pixels B_len. Power is a function used to raise a number or array element-wise to a specified power. These three groups of parameters are labeled as Level 1, Level 2, and Level 3, with the speeds ranging from slow to fast and the effects ranging from low to high. If not specified, the second group of parameters is used by default in the following tests.

The encrypted and decrypted images are shown in Figure 13. To facilitate the layout, we have resized the images to the same size, but the actual amount of pixels encrypted remains the same. It can be seen that the images are encrypted into noisy images and their original contents cannot be recognized.

5.1. Key Space Analysis

The key space refers to the total number of possible keys. In this paper, the keys are set as parameters of the chaotic system, including control parameters a, b and initial parameters x₀, y₀ and iteration parameters t. In a platform with a computational accuracy of 10⁻¹⁴, the key space is 10^14×4 > 2¹⁸⁶. A key space of at least 2¹⁰⁰ is required to resist brute force attacks [40]. Since ND-CMCM can generate multidimensional chaotic systems, it is only necessary to generate chaotic systems of two dimensions or more to resist brute force attacks.

5.2. Key Sensitivity Analysis

A key-sensitive algorithm means that even a very small change in the key can produce completely different results. The proposed chaotic system has good sensitivity to the initial conditions, and very small changes in the parameters generate completely different chaotic sequences, thus making the decryption results different. In the case of using SHA-512 to generate the key, a = 128.2116103055887, b = 103.4568560525077, x₀ = 0.803690307174427, y₀ = 0.750177111375968, t = 1973, after modifying the number at the end of a, a = 128.2116103055888, and the decrypted image obtained is shown in Figure 14. In the case of the custom key, we set a = 123.45, b = 567.89, x₀ = 0.12345, y₀ = 0.56789, t = 1000 and the decrypted image shown in Figure 14 is after adding 10⁻¹⁴ to x₀. It can be seen that the decrypted images are all unrecognizable, which shows that the proposed encryption algorithm has good key sensitivity.

5.3. Histogram Analysis

The histogram of the image shows the distribution of all pixel values and visualizes the frequency of pixel occurrences. The histogram of the test image counts the number of pixels from 0 to 255, as shown in Figure 15. The color image has three channels, while the grayscale image has only one. The histograms of the ciphertext images are close to horizontal, indicating that the pixels appear almost equally often and the attacker cannot decrypt them from the statistical analysis.

5.4. Chosen Plaintext Attack Analysis

An attacker can break the encryption by choosing to encrypt a specific plaintext to obtain a plaintext–ciphertext pair. We encrypted a 512 × 512 × 3 pure black image and a pure white image, and the test results are represented in Figure 16. It can be seen that the special images are still unrecognizable as noisy images after encryption. The test data of pure black and pure white are also added in the subsequent tests.

5.5. Differential Attack Analysis

Differential attack is a method that involves continuously modifying plaintext images, encrypting them, and comparing the resulting ciphertext images to obtain key information. The number of pixels change rate (NPCR) and the uniform average change intensity (UACI) are commonly used to test the resistance of image encryption algorithms to differential attacks. Considering encrypting a plaintext image of size M × N to obtain a ciphertext image C₁ and modifying the plaintext image by a one-pixel value to obtain a ciphertext image C₂, the NPCR and UACI are calculated as follows.

$$NPCR=\frac{{\displaystyle {\sum }_{ij}D\left(i,j\right)}}{M\times N}\times 100\%$$

(30)

$$UACI=\frac{1}{M\times N}\left[{\displaystyle \sum _{ij}\frac{\left|C_1\left(i,j\right)-C_2\left(i,j\right)\right|}{255}}\right]\times 100\%$$

(31)

$$D\left(i,j\right)=\left\{\begin{array}{cc}1\hfill & C_1\left(i,j\right)\ne C_2\left(i,j\right)\\ 0\hfill & C_1\left(i,j\right)=C_2\left(i,j\right)\end{array}\right\}$$

(32)

When the NPCR is close to 99.6094070% and the UACI is close to 33.4635070%, the image encryption algorithm can be considered to have a strong resistance to differential attacks [41,42]. The NPCR and UACI for encrypting different images are listed in

Table 1. NPCR and UACI for encrypting different images.

Key Type	Image	Size	Level 1		Level 2		Level 3
			NPCR (%)	UACI (%)	NPCR (%)	UACI (%)	NPCR (%)	UACI (%)
Key generated by SHA-512	5.1.11	256 × 256 × 1	99.6184	33.4516	99.6120	33.4797	99.6445	33.5498
	1.1.01	512 × 512 × 1	99.6088	33.4600	99.6132	33.4604	99.6235	33.5580
	1.3.01	1024 × 1024 × 1	99.6108	33.4651	99.6078	33.4424	99.6058	33.4144
	4.1.01	256 × 256 × 3	99.6049	33.4838	99.6119	33.4793	99.5900	33.4514
	4.2.01	512 × 512 × 3	99.6146	33.4744	99.6131	33.4682	99.6260	33.4593
	2.2.01	1024 × 1024 × 3	99.6087	33.4596	99.6102	33.4637	99.6088	33.4732
	Pure black	512 × 512 × 3	99.6084	33.4465	99.6111	33.4456	99.6241	33.4705
	Mean	-	99.6107	33.4630	99.6113	33.4627	99.6175	33.4824
Customized key	5.1.12	256 × 256 × 1	99.5911	33.2539	99.6030	33.5674	99.6124	33.5947
	5.2.10	512 × 512 × 1	99.5975	33.3703	99.6088	33.4564	99.6029	33.4332
	5.3.01	1024 × 1024 × 1	99.6031	33.4669	99.6107	33.4592	99.6011	33.4326
	4.1.05	256 × 256 × 3	99.5967	33.4399	99.6014	33.4807	99.6282	33.4856
	4.2.05	512 × 512 × 3	99.6015	33.4614	99.6084	33.4686	99.6160	33.4847
	6.2.02	1024 × 1024 × 3	99.6111	33.4849	99.6099	33.4630	99.6044	33.4669
	Pure white	512 × 512 × 3	99.6168	33.4971	99.6032	33.4590	99.6170	33.4838
	Mean	-	99.6025	33.4249	99.6065	33.4792	99.6117	33.4831

. This table indicates that the secret key generated by SHA-512 maintains good resistance to differential attacks at any size. However, the customized key exhibits performance degradation at small image sizes, possibly due to the limited number of diffusions caused by the small image sizes.

5.6. The Correlation between Adjacent Pixels Analysis

The correlation of adjacent pixels of an image can be measured by the correlation coefficient. The correlation coefficient is calculated as:

$$Co{r}_{xy}=\frac{{\displaystyle \sum _{i=1}^N\left[x_i-\frac{1}{N}{\displaystyle \sum _{i=1}^N{x}_i}\right]\left[y_i-\frac{1}{N}{\displaystyle \sum _{i=1}^N{x}_i}\right]}}{\sqrt{{\displaystyle \sum _{i=1}^N{\left[x_i-\frac{1}{N}{\displaystyle \sum _{i=1}^N{x}_i}\right]}^2}}\times \sqrt{{\displaystyle \sum _{i=1}^N{\left[y_i-\frac{1}{N}{\displaystyle \sum _{i=1}^N{x}_i}\right]}^2}}}$$

(33)

where x_i and y_i are two sequences of pixels of length N and y_i is an adjacent pixel of x_i. There is the presence of a strong correlation among adjacent pixels within a plaintext image. A smaller correlation coefficient of neighboring pixels of the ciphertext image indicates a better performance of the algorithm. Good image encryption algorithms aim to reduce the adjacent pixel correlation coefficient to close to 0. We randomly selected 10,000 pairs of adjacent pixels in the horizontal, vertical, and diagonal directions of image “4.2.05”, respectively, and plotted the correlation graph in Figure 17. In addition,

Table 2. Correlation coefficients for the plaintext images and ciphertext images.

Image	Size	Direction	Plaintext Image	Ciphertext Image
				Level 1	Level 2	Level 3
4.1.01	256 × 256 × 3	H	0.9679	−0.0032	0.0040	0.0019
		V	0.9588	0.0065	0.0068	0.0067
		D	0.9447	0.0019	−0.0010	0.0028
5.2.10	512 × 512 × 1	H	0.9317	0.0199	−0.0054	−0.0022
		V	0.9435	−0.0029	0.0000	0.0063
		D	0.9036	−0.0075	0.0003	0.0009
4.2.05	512 × 512 × 3	H	0.9604	0.0022	−0.0044	−0.0015
		V	0.9543	0.0066	0.0036	0.0009
		D	0.9251	0.0027	−0.0011	−0.0014
5.3.01	1024 × 1024 × 1	H	0.9818	−0.0062	0.0051	0.0001
		V	0.9769	0.0074	0.0005	−0.0018
		D	0.9665	0.0087	0.0047	0.0001
Pure black	512 × 512 × 3	H	-	−0.0045	−0.0020	−0.0014
		V	-	0.0082	0.0005	−0.0065
		D	-	0.0066	0.0040	−0.0013

shows the specific values of the correlation coefficients for the plaintext and ciphertext images at different levels of multiple images.

5.7. Information Entropy Analysis

Information entropy is a quantification of the randomness of the image pixels and helps to compare the degree of randomness of the encryption. Information entropy can be calculated as follows.

$$IE=-{\displaystyle \sum _{i=0}^{Q}p\left(x_i\right){\log }_{2}p\left(x_i\right)}$$

(34)

where Q denotes the number of gray levels, p(x_i) denotes the occurrence probability of pixel x_i. For an 8-bit image, the maximum information entropy is 8. Higher information entropy indicates higher security. The information entropy of each plaintext image and ciphertext image is given in

Table 3. Information entropy of plaintext image and ciphertext image.

Image	Size	PI	CI			Image	Size	PI	CI
			Level 1	Level 2	Level 3				Level 1	Level 2	Level 3
5.1.11	256 × 256 × 1	6.4523	7.9971	7.9975	7.9978	5.1.12	256 × 256 × 1	6.8981	7.9977	7.9981	7.9979
1.1.01	512 × 512 × 1	6.7057	7.9993	7.9992	7.9994	5.2.10	512 × 512 × 1	7.0686	7.9993	7.9992	7.9993
1.3.01	1024 × 1024 × 1	7.6702	7.9998	7.9998	7.9998	5.3.01	1024 × 1024 × 1	7.2428	7.9999	7.9998	7.9998
4.1.01	256 × 256 × 3	5.7056	7.9990	7.9992	7.9992	4.1.05	256 × 256 × 3	6.6639	7.9998	7.9998	7.9998
4.2.01	512 × 512 × 3	7.4404	7.9997	7.9998	7.9998	4.2.05	512 × 512 × 3	7.6133	7.9999	7.9999	7.9999
2.2.01	1024 × 1024 × 3	7.5237	7.9999	7.9999	7.9999	6.2.02	1024 × 1024 × 3	6.5786	7.9999	7.9999	7.9999
Pure black	512 × 512 × 3	0	7.9997	7.9998	7.9998	Pure white	512 × 512 × 3	0	7.9998	7.9998	7.9998

.

5.8. Robustness Analysis

Robustness tests can detect whether the receiver is still able to obtain useful information after the image has been subjected to various levels of noise contamination or cropping attacks. We used 1% and 5% salt and pepper noise to attack the ciphertext image and show the decrypted image after suffering from noise in Figure 18. In addition, we cropped 5%, 10% of the ciphertext image and show the decrypted image after suffering the cropping attack in Figure 19. In the proposed algorithm, there are two factors that will affect the robustness. The first factor is the newly defined LL operation. Unlike addition and XOR operations, the result of encrypted pixel values can be completely different even if one bit is changed. The second factor is diffusion, because intra-block diffusion and inter-block diffusion lead to the propagation of erroneous pixel values multiple times, resulting in multiple decryption errors of the pixel values.

5.9. Speed Analysis

Encryption speed is an important factor in the performance of image encryption. In this paper, several parameters affecting the encryption time are designed so that users can choose different levels of encryption speed according to their needs. Since the size of the encrypted image varies, we use 256 × 256 as the image unit to compare the time required to encrypt each unit. The encryption times for different sizes are shown in

Table 4. Encryption time.

Size	Level 1		Level 2		Level 3
	Time (s)	Time (s/Unit)	Time (s)	Time (s/Unit)	Time (s)	Time (s/Unit)
256 × 256 × 1	0.064	0.064	0.121	0.121	0.229	0.229
512 × 512 × 1	0.226	0.057	0.337	0.084	0.749	0.187
1024 × 1024 × 1	0.807	0.050	1.161	0.073	2.502	0.156
256 × 256 × 3	0.171	0.057	0.264	0.088	0.579	0.193
512 × 512 × 3	0.624	0.052	0.886	0.074	1.944	0.162
1024 × 1024 × 3	2.221	0.046	3.153	0.066	6.626	0.138
Mean	-	0.054	-	0.084	-	0.178

.

5.10. Comparison with Other Schemes

The proposed multiple-image encryption scheme is compared with some recent related schemes.

Table 5. Comparison with other schemes.

Scheme	NPCR (%)	UACI (%)	Correlation			IE	Time (s/Unit)
			Horizontal	Vertical	Diagonal
Ref. [18]	99.6229	33.4809	0.0019	0.0012	0.0020	7.9994	-
Ref. [43]	99.6060	33.5126	−0.0003	0.0011	0.0013	7.9998	0.107
Ref. [44]	-	-	0.0044	−0.0050	−0.0002	-	0.515
Ref. [45]	99.6167	33.4772	−0.0036	−0.0049	−0.0023	7.9993	-
Ref. [46]	99.6200	33.4600	0.0013	0.0009	−0.0018	7.9999	0.540
Ref. [47]	99.6085	33.4634	0.0011	0.0008	0.0015	7.9993	0.320
Ref. [48]	99.6012	33.4418	0.0015	−0.0002	−0.0004	7.9996	0.503
Ref. [49]	99.6077	33.4399	−0.0016	0.0057	−0.0189	7.9996	1.711
Ref. [50]	99.6367	33.3733	0.0116	0.0057	0.0039	7.9994	-
Ref. [51]	99.6174	33.4657	−0.0164	0.0056	0.0289	7.9993	0.123
Level 1	99.6107	33.4630	0.0022	0.0066	0.0027	7.9993	0.054
Level 2	99.6113	33.4627	−0.0044	0.0036	−0.0011	7.9994	0.084
Level 3	99.6175	33.4824	−0.0015	0.0009	−0.0014	7.9994	0.178

compares NPCR, UACI, correlation coefficient, information entropy, and encryption speed. The table exhibits that the proposed algorithm has better performance along with good efficiency. The encryption performance is passable even for the relatively low encryption Level 1. Adjusting the parameters B_min, B_max, and L_num to obtain a higher encryption level actually makes the computational complexity of the encryption increase. However, since the data are all close to the ideal values, it is difficult to see the exact difference.

6. Conclusions

We propose ND-CMCM to overcome the drawbacks of the current existing chaotic systems. The chaotic model can generate chaotic maps with different dimensions to satisfy different scenarios. Simulation experiments show that the chaotic systems generated by ND-CMCM have an infinite range of chaotic parameters with positive Lyapunov exponents equal to the dimension. Our proposed newly defined operations can be used in image encryption algorithms to replace the previously used operations such as modular sum, XOR, and finite field with higher complexity. The proposed overlapping block-based permutation algorithm not only scrambles the position and value of pixels efficiently but also controls the number of pixels being encrypted by adjusting the length of the overlapping block. Our proposed image encryption algorithm gives a lot of freedom to the user: the chaotic system can be customized, the secret key can be set freely, there can be no restriction on the image type, number, and size, and different encryption levels can be set. The algorithm can be universally used in various scenarios and under different requirements to fulfill a wide range of needs. In addition, the algorithm has high efficiency while the encryption performance reaches the ideal standard and can cope with many different attacks. In future research, we will work on image encryption schemes with stronger robustness and explore ways to apply these proposed encryption schemes to daily life.