Robust 3D Multi-Image Encryption Scheme Based on Rubik’s Cube–Poker Model

Abstract

In the age of big data, multimedia communication is becoming one of the most important communication methods. Therefore, it is important to overcome the challenge of processing numerous images safely and efficiently. In this paper, a 3D cross-image encryption scheme is proposed based on the Rubik’s Cube–poker model. The proposed scheme has the following properties: Firstly, it has flexible input image requirements to improve its applicability. Secondly, it has a strong ability to recover from data loss and retains important information in the reconstructed image. Finally, it achieves a lower time cost. Under the same input conditions in the grayscale color space, our proposed scheme achieves an execution time of 0.62 s, which is significantly lower than that of other schemes. The simulation results confirm the correctness, security, and robustness of the scheme.

1. Introduction

With the rapid development of Internet technology and multimedia technology, multimedia communication based on images has gradually become an important means for modern people to exchange information. Therefore, it is crucial to conduct research on image information security protection technologies.

Image encryption, steganography, and watermarks are the three main techniques for protecting the security of digital images. Important text or image information will be hidden by steganography, which embeds the information in the carrier [1,2,3,4,5]. Image watermarks can successfully safeguard the copyright of artistic creations by providing authentication information incorporated in the image [6,7,8,9]. Image encryption turns the original image into noise-like snowflake images by using scrambling and diffusion [10,11,12].

The development of encryption techniques specifically for images is challenging because traditional text encryption methods, such as DES, AES, and RSA, face several issues when applied to images, including a high time cost, strong correlation, and poor diffusion and scrambling performance. To overcome these limitations, chaos theory has been introduced into the design of image encryption schemes, providing new directions for secure and efficient encryption models. It is a challenge to design a multi-image encryption scheme which has both a low time cost and high pixel perturbation. We suggest a 3D multi-image encryption scheme based on the Rubik’s Cube-and-poker model. Our scheme has the following properties:

• Scheme principle The scheme is based on the principle of the Rubik’s Cube-and-poker model, which provides a vast number of states. It can change the positions of a large number of pixels with simple operations in order to achieve the aim of balancing the time cost and scrambling effects.
• Input flexibility In many existing 3D multi-image encryption schemes, the input image must be able to construct an $N\times N\times N$ cube. In our scheme, we also propose a solution for a general case, and we can encrypt any number and size of input images at the same time.
• Pixel scrambling A Rubik’s Cube has complex disorder characteristics. Inspired by the complexity of high-order Rubik’s Cube restoration combined with the shuffling of poker cards, we designed a Rubik’s Cube–poker model for image pixel scrambling. The model can not only shuffle the pixels sufficiently, but can also change a large number of pixels in each iteration. Therefore, our scheme based on this model can make a good tradeoff between time and efficiency. Moreover, it has a strong ability to recover from data loss after occlusion attacks, and retains important information in the reconstructed image.

The remaining contents of this paper are organized as follows: Section 2 introduces a detailed review of related work in this field, Section 3 introduces the principles, Section 4 proposes a new scrambling method and a new multi-image encryption scheme, Section 5 describes the simulation experiment analysis, and the Section 6 gives the conclusions.

2. Related Work

In recent years, numerous image encryption techniques have been proposed to address the increasing demand for secure image transmission and storage. These techniques vary in their underlying principles, complexity, and effectiveness in resisting attacks. In this section, we present a brief review of representative and influential studies in the field of image encryption to provide the necessary background.

The year 1992 saw the introduction of Bourbakis and Alexopoulos’ SCAN language-based image encryption method, which combines encryption and compression [13]. Using the ergodicity and high sensitivity of chaotic systems, Fridrich and Jiri proposed an image encryption method based on chaos in 1998 [14]. Since then, experts have started to focus on and advance chaos-based image encryption [15,16,17,18,19,20,21,22]. The traditional method of encrypting photographs involves transforming the original image into noise- and texture-like graphics, and this characteristic ends up serving as a sign that the images are encrypted. In 2015, Long Bao and Yicong Zhou merged image encryption with steganography to suggest a visual image encryption system with visual relevance in an effort to lessen the likelihood of an attack [23]. Discrete wavelet transform (DWT) is used to embed the encrypted image into the carrier image, making it visually indistinguishable from the natural image. Recent work by Chen et al. further advanced this field by introducing a two-order bit compass coding technique combined with chaotic mapping, which enhances pixel diffusion through bit-level operations and pseudo-random integer generation, addressing both security and computational efficiency [24]. Çelik and Doğan present a hybrid image encryption scheme combining affine transformation, substitution cipher, and an improved logistic chaotic map [25]. They employ a dual-phase process with affine-based pre-encryption and chaos-driven substitution. This method enhances security through geometric transformation, nonlinear mapping, and dynamic chaos while ensuring efficiency with a single-round design.

The need for the effective processing of numbers of images is growing in the age of big data, and the above single-image encryption solution struggles to keep up with the demand for batch encryption. The development of multi-image encryption methods has significantly increased the effectiveness of encryption [26,27,28,29,30,31,32,33]. In 2018, Zhang and Wang proposed a 3D permutation model based on chaotic systems to scramble pixel positions across multiple images, demonstrating improved security and efficiency [33]. Hanif et al. suggested a 3D multi-image encryption strategy based on chaotic system and exchange operation [29]. After constructing a cube, the pseudo-random sequence produced by the chaotic system chooses and switches out the cube’s rows and columns in order to disturb the original structure. Each cycle of iteration only involves a few pixels, so it is time-consuming. Sahasrabuddhe et al. greatly reduce the time cost of the process through layer-by-layer rearrangement of the three dimensions of the constructed original cube using a pseudo-random sequence created by the chaotic system [31]. However, pixel perturbation is insufficient, so occlusion attacks may result in great loss of important information. In 2024, Li proposed an image encryption algorithm based on an improved 3D hyper-chaotic system [34]. This work achieves resistance to plaintext attacks through dynamic property optimization and hash binding. By integrating bit-plane permutation, crossover-box scrambling, and forward–backward diffusion mechanisms, it ensures high security, robustness against attacks, and efficient single-round encryption. Ponnambalam et al. recently proposed two representative innovative schemes [35,36]. The first work proposes a robust color image encryption scheme based on a novel 3D Complex Whirlwind Spiral chaotic system (3D CWWS) and Quadrant-Wise Pixel Permutation (QWPP), which enhances security through strengthened chaotic dynamics and a multi-stage encryption process [35]. By integrating chaotic sequence-driven diffusion and QWPP-based pixel scrambling, the scheme achieves exceptional resistance to statistical and differential attacks. The second work introduces a method integrating kolam scrambling with an improved 2D chaotic map, employing layered pixel permutation and dynamic encoding strategies to optimize computational efficiency while maintaining low pixel correlations [36].

3. Preliminaries

To better understand the design principles underlying our scheme, it is essential to first introduce the fundamental theories and techniques involved. This section describes the main principles, including the intertwining logistic map and the Rubik’s Cube principle. The former generates a key stream through multi-dimensional chaotic iteration, while the latter simulates three-dimensional block permutation based on the Rubik’s Cube to achieve spatial scrambling of image pixels. The combination of these two methods effectively enhances the complexity of the encryption scheme and its resistance to attacks.

3.1. Intertwining Logistic Map

The logistic map is one of the most commonly used chaotic maps, and the chaotic sequence generated by it is highly sensitive to changes in the initial values. It can provide a good pseudo-random effect but still has a few weaknesses, such as an uneven sequence distribution, blank Windows, and weak keys. I.S.Sam et al. proposed a new chaotic map named the intertwining logistic map to increase the chaotic key space, and made the generated sequence uniformly distributed [37]. The interleaving logical map is defined as follows:

$$\begin{array}{cc}\hfill & x_{n+1}=(\mu \times k_1\times y_n\times (1-x_n)+z_n)mod1,\hfill \\ \hfill & y_{n+1}=(\mu \times k_2\times y_n+z_n\times 1/(1+x_{n+1}^2))mod1,\hfill \\ \hfill & z_{n+1}=(\mu \times (x_{n+1}+y_{n+1}+k_3)\times sin{z}_n)mod1,\hfill \end{array}$$

(1)

where $0<\mu \le 3.999$, $\mid k_1\mid >33.50$, $\mid k_2\mid >37.97$, $\mid k_3\mid >35.7$.

3.2. Rubik’s Cube Rotation Model

The Rubik’s Cube is a generalized representation of all kinds of geometric bodies that can be disrupted and restored by rotation. The rule of the Rubik’s Cube is to rotate it from a scrambled state to its original state. The number of states in different orders of the Rubik’s Cube can be calculated as follows.

$$N=\left\{\begin{array}{c}\frac{8!\times 3^7\times 12!\times 2^{10}\times {(24!)}^{\frac{(n-3)(n+1)}{4}}}{{24}^{\frac{3[{(n-2)}^2-1]}{2}}},n=2k+1\hfill \\ \frac{7!\times 3^6\times {(24!)}^{\frac{n(n-2)}{4}}}{{24}^{\frac{3{(n-2)}^2}{2}}},n=2k\hfill \end{array}\right.$$

(2)

Some existing image encryption algorithms based on the Rubik’s Cube theory use the Rubik’s Cube principle to scramble two-dimensional images through shift operations, such as Loukhaoukha et al. [38]. Zhu et al. used the Rubik’s Cube method to encrypt two-dimensional images at the bit level [39]. Nair et al. used Rubik’s Cube movement to generate scrambled sequences, and then randomly shuffled the bit planes to generate encrypted images [40]. These schemes based on the principle of the Rubik’s Cube generally use Rubik’s Cube color information to refer to pixels. In our proposed scheme, the entire Rubik’s Cube is regarded as a 3D image, and each block of the Rubik’s Cube is regarded as a pixel. The pixels of the entire 3D image can be scrambled by simulating the operation of rotating the Rubik’s Cube. Correspondingly, scrambling can be achieved through the operation of Rubik’s Cube restoration. Therefore, the principle of the Rubik’s Cube can be used to disrupt the pixel positions of images, thereby protecting the security of the images.

Classic image encryption algorithms based on the Rubik’s Cube principle typically rely on the outermost layers of the cube to represent image pixels, performing scrambling through bit-level or block-level transformations during cube rotations. However, in our proposed scheme, the Rubik’s Cube is treated as a complete 3D structure, where both the outer and inner blocks carry image information, thereby improving resource utilization. By incorporating shuffling operations to swap the inner and outer layers, a higher degree of pixel perturbation is achieved. Based on this design, we propose a Rubik’s Cube-poker model.

3.3. Dynamic Behavior Analysis

3.3.1. Phase Diagram of Our Scheme

Figure 1 and Figure 2 depict the phase-space attractor with the initial conditions x(1) = 0.5142, y(1) = 0.0730, z(1) = 0.2475 and system parameters $\mu =3.99, k_1=36.9, k_2=41.4, k_3=40.0$.

Figure 1. Three-dimensional phase diagram.

Figure 2. Phase diagram. (a) x–y projection. (b) x–z projection. (c) y–z projection.

3.3.2. Bifurcation Diagram of Our Scheme

Figure 3 demonstrates the bifurcation characteristics under parametric control $\mu \in (0,3.999],$$k_1=36.9, k_2=41.4, k_3=40.0$, and also uses x(1) = 0.5142, y(1) = 0.0730, z(1) = 0.2475 as the initial conditions.

Figure 3. Bifurcation diagrams of the chaotic system in different dimensions. (a) x-dimension. (b) y-dimension. (c) z-dimension.

3.3.3. Lyapunov Exponents of Our Scheme

The defining feature of chaotic systems lies in their extreme sensitivity to initial values. The Lyapunov exponent (LE), as a key quantitative metric in dynamical systems research, precisely measures this sensitivity to initial conditions and serves as a crucial criterion for identifying chaotic phenomena. It quantifies the average exponential rate of convergence or divergence between adjacent trajectories in phase space:

• A positive LE value $(\lambda >0)$ indicates the exponential divergence of neighboring trajectories, signifying the emergence of chaotic behavior;
• A negative LE value $(\lambda <0)$ corresponds to the gradual convergence of trajectories, reflecting stable dynamical behavior governed by predictable attractors.

Figure 4 presents the variation in the Lyapunov exponent for the intertwining logistic map with respect to the control parameter $\mu$. As can be seen from Figure 4, the Lyapunov exponents of the intertwining logistic map are all positive, indicating that the sequences generated by the map possess sufficient randomness.

Figure 4. Lyapunov exponent.

4. Proposed Scheme

With the necessary preliminaries established, we are now ready to introduce our proposed Rubik’s Cube–poker model for image scrambling; the encryption and decryption schemes based on this model are given, and the non-standard case is analyzed. As shown in Figure 5, the encryption algorithm can be divided into four steps:

Figure 5. A flow chart of our scheme.

• Cube construction $\mathbb{I}\to Cub{e}_{ori}$, where $\mathbb{I}$ is the set of input images, and $Cub{e}_{ori}$ is the $N\times N\times N$ original cube.
• Initialization and key generation $(Cub{e}_{ori},K)\to (A,B,C,Ke{y}_{3D})$, where K is the user key, A,B,C are the operation sequences, and $Ke{y}_{3D}$ is the 3D key.
• Cube scrambling $(Cub{e}_{ori},A,B,C)\to Cub{e}_{scr}$, where $Cub{e}_{scr}$ is the scrambled cube.
• Encryption $(Cub{e}_{scr},Ke{y}_{3D})\to Cub{e}_{enc}$, where $Cub{e}_{enc}$ is the encrypted cube.

As a symmetric encryption, the steps of the decryption algorithm are as follows:

• Initialization and key generation $(h,K)\to (A,B,C,Ke{y}_{3D})$, where h is the hash value of $Cub{e}_{ori}$.
• Decryption $(Cub{e}_{enc},Ke{y}_{3D})\to Cub{e}_{dec}$, where $Cub{e}_{dec}$ is the decrypted cube.
• Cube descrambling $(Cub{e}_{dec},A,B,C)\to Cub{e}_{des}$, where $Cub{e}_{des}$ is the descrambled cube.

4.1. Cube Construction

We can divide the multiple 2D plain images into blocks and stack the blocks to generate a 3D cube. Based on the size and number of the input 2D images, any size of 3D cube can be selected. Some examples of the relationships between the quantity and size of input images and cubes are shown in Table 1. Our scheme also provides solutions for non-standard cases where the input image cannot easily construct a cube. These will be discussed later.

Table 1. Examples of 3D cubes generated from 2D images.

Size of Cube	Size of Images	Number of Images
$128\times 128\times 128$	$256\times 256$	32
	$512\times 512$	8
	$1024\times 1024$	2
$256\times 256\times 256$	$256\times 256$	256
	$512\times 512$	64
	$1024\times 1024$	16
$512\times 512\times 512$	$512\times 512$	512
	$1024\times 1024$	128
	$2048\times 2048$	32

4.2. Initialization and Key Generation

The SHA function and an interleaved logistic map were used to generate the operation sequence and 3D key for the constructed 3D cube. The specific steps were as follows:

• Choose a set of 256-bit binary numbers as the user key.
• Calculate SHA256 on the 3D cube (the result is h), and XOR it with the user key to generate a binary number $H_0$ of length 256 for generating chaotic maps:

  $$H_0=h\oplus key.$$

  (3)
• Every eight bits of the binary number $H_0$ generated in Step 2 is converted into a decimal number, and a decimal array H of length 32 is generated. The parameters of the interleaved logistic map are calculated according to the following formula:

  $$\begin{array}{cc}\hfill & H_m=\sum H(4i-(4-m)),m=1, 2, 3, 4.\hfill \\ \hfill & k_m=\frac{H_m}{256}+c_m,wherem=1, 2, 3.c_1=33.5,c_2=37.97,c_3=35.7.\hfill \\ \hfill & \mu =\frac{H_4}{256}(mod3.99)+0.009.\hfill \end{array}$$

  (4)
• Compute the initial values of the chaotic map:

  $$\begin{array}{cc}\hfill & x_1=\frac{k_1 \times k_2 \times k_3}{\mu }(mod0.999),\hfill \\ \hfill & y_1=\frac{k_2 \times \mu }{k_1 \times k_3 \times x_1}(mod0.999),\hfill \\ \hfill & z_1=\frac{k_3 \times \mu \times x_1}{k_1 \times k_2 \times y_1}(mod0.999).\hfill \end{array}$$

  (5)
• The parameters and initial values are input into the interleaved logistic map, and the chaotic sequences x, y, z are obtained by performing an iterative calculation. Then, the first 100 data of x, y, z are discarded to eliminate the transient effect.
• Sequences u, v, w are generated from the chaotic sequences x, y, z:

  $$\begin{array}{cc}\hfill & [\sim ,u]=sort\left(x\right),\hfill \\ \hfill & [\sim ,v]=sort\left(y\right),\hfill \\ \hfill & [\sim ,w]=sort\left(z\right),\hfill \end{array}$$

  (6)

  where $[p,q]=sort\left(x\right)$ means that all values of sequence x are sorted in ascending order and output as sequence p, and the index at the corresponding position in is output as sequence q. ∼ means that the current value does not need to be output.
• Calculate the operation sequences based on u, v, w:

  $$\begin{array}{cc}\hfill & A=u(modN)+1,\hfill \\ \hfill & B=v(modN)+1,\hfill \\ \hfill & C=w(mod3)+1.\hfill \end{array}$$

  (7)
• Based on the modulo operation, the chaotic sequences x, y, z are converted into a 3D key as follows:

  $$\begin{array}{cc}\hfill & ke{y}_{3d}(2i-1,2j-1,k)=\lfloor x\left(num\right)\times 2^{12}\rfloor (mod256),\hfill \\ \hfill & ke{y}_{3d}(2i-1,2j,k)=\lfloor y\left(num\right)\times 2^{12}\rfloor (mod256),\hfill \\ \hfill & ke{y}_{3d}(2i,2j-1,k)=\lfloor z\left(num\right)\times 2^{12}\rfloor (mod256),\hfill \\ \hfill & ke{y}_{3d}(2i,2j,k)=\lfloor x\left(num\right)\times y\left(num\right)\times z\left(num\right)\times 2^{12}\rfloor (mod256),\hfill \end{array}$$

  (8)

  where $num$ is the total number of times that the nested loop has been looped, and $i,j,k$ represent the number of times that the cube has been looped in the $x,y$ and z axis directions, respectively.

4.3. Cube Scrambling: Rubik’s Cube–Poker Model

We propose a 3D scrambling method combining the benefits of the Rubik’s Cube rotation model and poker shuffle model. In the three-dimensional coordinate system, we define the set of all pixels with the same x coordinates as an x plane, the set of all pixels with the same y coordinates as a y plane, and the set of all pixels with the same z coordinates as a z plane. As shown in Figure 6, in one single round of iteration, one operation of rotation on an x plane, one operation of rotation on a y plane, and one operation of shuffle on z planes are carried out to sufficiently scramble the pixels. The scrambling process is as follows:

Figure 6. Rubik’s Cube–poker model for image scrambling.

• Input three operation sequences, A, B and C, where A and B are in the range $[1,N]$, and C is in the range $[1, 3]$. Define the total number of iterations K such that K is an integer multiple of i. In the ith iteration, carry out the following:
• Rotate the $A\left(i\right)$th x plane of the cube, as shown in Figure 6a. If $C\left(i\right)=1$, rotate the plane 90 degrees; if $C\left(i\right)=2$, rotate the plane 180 degrees; and if $C\left(i\right)=3$, rotate the plane 270 degrees.
• Rotate the $B\left(i\right)$th y plane of the cube, as shown in Figure 6b. If $C\left(i\right)=1$, rotate the plane 90 degrees; if $C\left(i\right)=2$, rotate the plane 180 degrees; and if $C\left(i\right)=3$, rotate the plane 270 degrees.
• As shown in Figure 7a, denote all of the z planes in the range $[min,max]$ as pile 2, all the z planes in the range $[1,min-1]$ as pile 1, and all the z planes in the range $[max+1,N]$ as pile 3, where $min=min\left(A\right(i),B(i\left)\right)$, $max=max\left(A\right(i),B(i\left)\right)$. If $C\left(i\right)=1$, pull pile 2 out and put it on top, as shown in Figure 7b; if $C\left(i\right)=2$, pull pile 2 out and put it at the bottom, as shown in Figure 7c; and if $C\left(i\right)=3$, swap pile 1 and pile 3, as shown in Figure 7d.
  

  Figure 7. Encryption z plane shuffle.

4.4. Encryption

The scheme adopts a sequence cipher symmetric encryption system, where a 3D key sequence of the same length as the $N\times N\times N$ original cube is generated from the user key, and encryption is achieved through bitwise XOR operation between the 3D key and the scrambled cube:

$$Cub{e}_{enc}=ke{y}_{3D}\oplus Cub{e}_{scr},$$

(9)

where $Cub{e}_{scr}$ refers to the cube after it has been scrambled.

4.5. Decryption

Given that the encryption process is symmetric, the decryption procedure only requires the application of the decryption step followed by inverse scrambling. Initially, the 3D key and the operation sequence are reconstructed from the hash value of the original cube, following the same procedure as described in the Initialization and Key Generation phase.

The scrambled cube before encryption can be obtained by applying an XOR operation between the encrypted cube and the 3D key.

$$Cub{e}_{scr}=ke{y}_{3D}\oplus Cub{e}_{enc},$$

(10)

where $Cub{e}_{scr}$ refers to the cube after it has been scrambled.

4.6. Cube Descrambling

• Input three operation sequences, A, B, and C, where A and B are in the range $[1,N]$, and C is in the range $[1,3]$. Define the total number of iterations K such that K is an integer multiple of i. During the ith iteration, calculate $m=K-i+1$:
• If $C\left(m\right)=1$, divide the array into three piles. Denote all the z planes in the range $[max-min+2,max]$ as pile 1, all the z planes in the range $[1,max-min+1]$ as pile 2, and all the z planes in the range $[max+1,N]$ as pile 3, where $min=min\left(A\right(m),B(m\left)\right)$, $max=max\left(A\right(m),B(m\left)\right)$. If $C\left(m\right)=2$, denote all the z planes in the range $[1,min-1]$ as pile 1, all the z planes in the range $[N-max+1,N]$ as pile 2, and all the z planes in the range $[min,N-max]$ as pile 3. If $C\left(m\right)=3$, denote all the z planes in the range $[N-min+2,N]$ as pile 1, all the z planes in the range $[N-max+1,N-min+1]$ as pile 2, and all the z planes in the range $[1,N-max]$ as pile 3.
• Rearrange the array in the order of pile 1, pile 2, and pile 3 from top to bottom to restore the original sequence.
• Rotate the $B\left(m\right)$th y plane of the cube. If $C\left(m\right)=1$, rotate the plane 270 degrees; if $C\left(m\right)=2$, rotate the plane 180 degrees; and if $C\left(m\right)=3$, rotate the plane 90 degrees.
• Rotate the $A\left(m\right)$th x plane of the cube. If $C\left(m\right)=1$, rotate the plane 270 degrees; if $C\left(m\right)=2$, rotate the plane 180 degrees; and if $C\left(m\right)=3$, rotate the plane 90 degrees.

4.7. The General Case

Considering the general case, for a situation in which it is difficult to construct a cube, an $N\times N\times M$ cuboid can be constructed.

• If $M<<N$, consider building a cuboid with smaller N.
• If $M<N$, perform the zero-filling operation, and carry out the original encryption scheme.
• If $M>N$, as shown in Figure 8, the original encryption process of x and y plane rotation is only carried out on the pixels of the $[1,N]$z planes. When shuffling the z plane, the bottom part is firstly placed at the top, and the gray part is rearranged according to the original scheme and placed at the top of the white part.
  

  Figure 8. General case.

5. Simulation and Analysis of the Proposed Scheme

To evaluate the efficiency, correctness, security, and robustness of the proposed image encryption scheme, simulations were conducted using MATLAB 2019a on a personal computer equipped with an Intel Core i7-9700 processor (3.00 GHz) and 16 GB RAM, running Windows 10 64-bit. The test images were selected from the USC-SIPI image database, including both grayscale and RGB images.

5.1. Key Space

The key space refers to the size and range of all possible values of the key. A sufficiently large key space makes brute-force attacks difficult for attackers, preventing them from easily guessing the correct key through exhaustive search. For image encryption, the minimum required key space is $2^{100}$.

In the proposed scheme, the secure key set consists of user-defined keys and the parameters and initial values of the intertwining logistic map. The user key is 256 bits long, allowing for $2^{256}$ different possible values. On a 64-bit computer, the parameters and initial values of the intertwining logistic map can take ${\left(2^{64}\right)}^7$ different combinations. Therefore, the total key space of this scheme is $2^{256}\times 2^{64}=2^{704}$. This means that a brute-force attack would require at most $2^{704}$ computations.

5.2. Key Sensitivity Analysis

We choose

$$K_0=7c256388fb8748aee59181c05195b31ab6e792e78b7a430302c40b7fcd2963d4,$$

represented in hexadecimal, as the user key and make tiny changes to obtain

$$K_1=7c256388fb8748aee59181c05195b31ab6e782e78b7a430302c40b7fcd2963d4,$$

$$K_2=7c256308fb8748aee59181c05195b31ab6e792e78b7a430302c40b7fcd2963d4,$$

$$K_3=7c256388fb8748aee59181c05195b31ab6e792e78b7a430302c40b7fcd2963dc.$$

We encrypt the input images shown in Figure 9a using $K_0$, $K_1$, $K_2$, and $K_3$, respectively. The differences between the 3D keys and the resulting encrypted cubes are presented in Table 2, and some images are shown in Figure 9.

Figure 9. Encryption and decryption images under different keys.

Table 2. Difference analysis.

Parameter	${\mathit{Key}}_{3\mathit{D}1}$	${\mathit{Key}}_{3\mathit{D}2}$	${\mathit{Key}}_{3\mathit{D}3}$	${\mathit{Cube}}_{\mathit{enc}1}$	${\mathit{Cube}}_{\mathit{enc}2}$	${\mathit{Cube}}_{\mathit{enc}3}$	${\mathbb{I}}_0$	${\mathbb{I}}_1$	${\mathbb{I}}_2$	${\mathbb{I}}_3$
NPCR	99.6075	99.6101	99.6091	99.6107	99.6120	99.6079	99.6095	99.6085	99.6094	99.6092
UACI	33.4603	33.4606	33.4565	33.4605	33.4607	33.4592	33.4687	33.4661	33.4769	38.9723

5.3. Plaintext Attack

In order to test the plaintext sensitivity of the proposed scheme, the following are defined:

(1)

${\mathbb{I}}_0$: A set of images consisting of eight $512\times 512$ grayscale images;

(2)

${\mathbb{I}}_1$: A set of eight $512\times 512$ RGB images shown in Figure 9a;

(3)

${\mathbb{I}}_2$: A set of pure black images with all pixel values being 0;

(4)

${\mathbb{I}}_3$ A set of pure white images with all pixel values being 255.

We construct plaintext cubes of $128\times 128\times 128$ using the above image sets, modify the pixel values at each cube $(64, 64, 64)$, and encrypt the cubes before and after the modification. We calculate the NPCR, UACI of encrypted cubes, as shown in Table 2.

5.3.1. Histogram Analysis

To resist statistical attacks, the histogram of the encrypted image must be uniform and completely different from that of the plaintext image. The histograms of a plaintext image are shown on the top row in Figure 10 and those of an encrypted image are shown on the bottom row. It can be observed that the histograms of the three channels in the plaintext cube are non-uniform, whereas those of the encrypted cube are uniform and exhibit a marked difference from the plaintext histograms. The ${\chi }^2$ test results and entropy are shown in Table 3.

Figure 10. RGB channel histogram.

Table 3. ${\chi }^2$ test and entropy under different keys.

	${\mathit{\chi }}^2$ Test				H(m)
Image	R	G	B	Result	R	G	B
$Cub{e}_{ori}$	990150.4304	727050.6143	1226878.9399	No pass	7.561091	7.5610912	7.604588
$Cub{e}_{enc0}$	258.7280	251.4902	272.5879	Pass	7.999911	7.999914	7.999906
$Cub{e}_{enc1}$	254.6936	225.4221	247.9204	Pass	7.999912	7.999922	7.999915
$Cub{e}_{enc2}$	227.5852	202.0659	236.6506	Pass	7.999922	7.999930	7.999919
$Cub{e}_{enc3}$	243.3135	246.6465	264.4690	Pass	7.999916	7.999915	7.999909
$Cub{e}_{enc4}$	256.1951	309.8210	261.0168	Pass	7.999912	7.999893	7.999910
$Cub{e}_{enc5}$	276.3867	234.1125	223.5225	Pass	7.999905	7.999919	7.999923

5.3.2. Correlation Analysis

A correlation analysis reflects the algorithm’s scrambling impact. In order to prevent statistical attacks, the strong connections must be broken. To analyze the correlation between adjacent pixels in this scheme, 10,000 pixels were randomly selected from both the original plaintext cube and the encrypted cube. For each selected pixel, its adjacent pixels were identified along seven directions: x, y, z, $xy$, $xz$, $yz$, and $xyz$. Correlation analysis scatter plots were drawn using the pixel values of each pair as the horizontal and vertical coordinates, as shown in Figure 11 and Figure 12. The corresponding correlation coefficients are listed in Table 4.

Figure 11. Correlation of original cube.

Figure 12. Correlation of encrypted cube.

Table 4. The correlation coefficient.

	${\mathit{Cube}}_{\mathit{ori}}$			${\mathit{Cube}}_{\mathit{enc}}$
${\mathit{P}}_{(\mathit{x},\mathit{y},\mathit{z})}$ Against	R	G	B	R	G	B
$P_{(x+1,y,z)}$	0.9459	0.9598	0.9694	0.0041	−0.0015	−0.0081
$P_{(x,y+1,z)}$	0.9530	0.9629	0.9728	0.0095	−0.0063	−0.0042
$P_{(x+1,y+1,z)}$	0.9207	0.9360	0.9530	−0.0075	0.0034	0.0022
$P_{(x,y,z+1)}$	0.2451	0.3258	0.5011	0.0017	−0.0027	0.0023
$P_{(x+1,y,z+1)}$	0.2394	0.3222	0.4950	0.0044	−0.0043	−0.0022
$P_{(x,y+1,z+1)}$	0.2425	0.3250	0.5006	0.0032	−0.0049	0.0012
$P_{(x+1,y+1,z+1)}$	0.2405	0.3217	0.4958	0.0013	−0.0026	−0.0031

It can be observed that the original plaintext cube exhibits strong correlations along the x, y, and $xy$ directions, while the correlations in the other four directions are slightly weaker. In contrast, the encrypted cube generated by the proposed scheme shows weak correlations in all seven directions. This indicates that the scheme effectively disrupts the correlation between adjacent pixels, demonstrating strong diffusion capability and resistance to statistical analysis attacks.

5.4. Robust Analysis

5.4.1. Occlusion

We deleted 25% and 50% of the encrypted cube to simulate an occlusion attack, as shown in Figure 13a. We treated all of the missing data as zeros. The decrypted images using our scheme are as shown in Figure 13b, and the decrypted images using scheme [31] are shown in Figure 13c. The quality analysis of the reconstructed images is shown in Table 5.

Figure 13. Data loss attack [31].

Table 5. Reconstructed image quality analysis.

Parameter	25% Data Loss	50% Data Loss	Gaussian Noise	Speckle Noise	Poisson Noise
PSNR	14.3825	11.3680	14.4291	13.5573	17.7152
SSIM	0.6559	0.4606	0.6475	0.6040	0.7855

Through comparative experiments and observations, the proposed scheme achieves more thorough pixel scrambling, thus possessing better data loss recovery capabilities. The reconstructed image can visually recognize the information contained in the input image. The scheme proposed by Sahasrabuddhe et al. uses a simple permutation operation to scramble image pixels [31]. Although the time complexity is lower and the execution efficiency is higher, the pixel scrambling is not thorough enough, as shown in Figure 13c. Although the part without lost data perfectly restores the entire content of the plaintext image, the part that suffers from data loss cannot be recovered at all, so it has the risk of losing key information. In comparison, our scheme scrambles pixels more thoroughly and has a better ability to recover from data loss.

5.4.2. Noise Attack

Encrypted images may experience noise disturbance when transmitted over unsecure channels. A good encryption scheme should have some tolerance for noise attacks. Gaussian noise, Poisson noise, and speckle noise were added to the encrypted cube, and the decrypted image is shown in Figure 14.

Figure 14. Noise attack.

5.5. Execution Speed

Table 6 provides comparison results with some existing encryption schemes in terms of execution time. It can be observed that our proposed scheme outperforms many existing multi-image encryption schemes in terms of time cost, and the color space of the input image can be either grayscale or RGB. Combined with the data loss analysis in the previous section, this scheme can achieve a good balance between encryption effect and efficiency, and can quickly and efficiently encrypt a large number of images.

Table 6. Execution speed for encryption of multiple images.

Input	Scheme	Colour Space	Time(s)
${\mathbb{I}}_0$	Our scheme	Grayscale	0.62
	Scheme [32]	Grayscale	18.68
	Scheme [29]	Grayscale	20.16
	Scheme [26]	Grayscale	17.57
${\mathbb{I}}_1$	Our scheme	RGB	1.73
	Scheme [31]	RGB	1.65
${\mathbb{I}}_2$	Our scheme	Grayscale	0.61

5.6. NIST Test

The National Institute of Standards and Technology Special Publication 80022 (NIST SP 800-22) provides a cryptographic-grade validation tool, employing 15 statistically rigorous methods to quantify the randomness of sequences. The p-value is the key indicator of statistical randomness compliance. A p-value exceeding the significance threshold (p-value > 0.01) demonstrates that the sequence under analysis exhibits no statistically significant deviation from a random distribution within the framework of the specified statistical test. The three chaotic sequences generated by the intertwining logistic map for 3D cryptographic key construction were formatted to comply with the NIST SP 800-22 test suite specifications. As shown in Table 7, all three chaotic sequences successfully passed 15 statistical tests within the NIST suite. The chaotic sequences generated by our scheme exhibit high randomness, providing a secure foundation for subsequent key generation and significantly enhancing the security of the encryption system.

Table 7. NIST randomness test of generated chaotic x y z sequence.

Type of Test (p-Value)	x	y	z	Result
01. Frequency	0.564401	0.545713	0.207898	Random
02. Block Frequency	0.434816	0.476841	0.571575	Random
03. Cumulative Sums	0.528471	0.562372	0.243916	Random
04. Runs	0.531982	0.662111	0.484130	Random
05. Longest Run of Ones	0.466725	0.549700	0.260893	Random
06. Rank	0.358719	0.416396	0.531489	Random
07. Discrete Fourier Transform	0.514115	0.279153	0.471152	Random
08. Nonperiodic Template Matchings	0.495596	0.486665	0.475385	Random
09. Overlapping Template Matchings	0.601758	0.497589	0.302095	Random
10. Universal Statistical	0.501780	0.491883	0.649048	Random
11. Approximate Entropy	0.488263	0.383432	0.112906	Random
12. Random Excursions	0.385597	0.543576	0.615127	Random
13. Random Excursions Variant	0.430826	0.581573	0.622297	Random
14. Serial	0.500078	0.447659	0.339206	Random
15. Linear Complexity	0.586180	0.604667	0.396825	Random

6. Conclusions

This paper proposes a new Rubik’s Cube–poker model for image scrambling and proposes a 3D multi-image encryption scheme based on the model. The scheme achieves a better balance between time efficiency and scrambling performance. Simulations and analyses show that it has high key sensitivity, low correlation, and robustness, and can effectively resist histogram analyses, occlusion attacks, noise attacks, differential attacks, etc. Compared with other multi-image encryption methods, this scheme has sufficient scrambling, a low time cost, and a low requirement for input images. Moreover, it has a strong ability to recover from data loss.

Although the proposed scheme strikes a good balance between encryption performance and efficiency, there are several areas that could benefit from further improvement in future research:

• While the Rubik’s Cube–poker model effectively shuffles a substantial portion of pixels, it does not guarantee full-range pixel perturbation in a single iteration. The scrambling model could be further optimized to involve a larger number of pixels in each iteration, enhancing the scrambling effect and improving overall encryption security.
• Although more efficient than many existing approaches, the scheme may still require further optimization to become suitable for large-scale applications. The encryption process can be streamlined to reduce computational time while maintaining robustness and security, aiming to improve its practicality for real-time or large-scale use cases.
• The current analysis primarily addresses occlusion and noise attacks. However, more advanced attack evaluations, such as known-plaintext attacks or chosen-ciphertext attacks, have not yet been explored. Expanding the evaluation to include these attack models would provide a more comprehensive understanding of the scheme’s security.