A Chaos-Based Image Encryption Algorithm via Integrated Cellular Automata and Tent Map Systems

Abstract

This study proposes a novel image encryption algorithm based on a two-dimensional discrete chaotic system that integrates cellular automata (CA) with a tent map. The algorithm addresses security vulnerabilities in digital image transmission and storage across open networks or cloud environments. It employs a three-phase encryption process: coordinate permutation, spatial permutation, and diffusion. Sequential application of Arnold’s coordinate scrambling, maze traversal-based spatial rearrangement, and a CA-driven diffusion mechanism enhances robustness against noise, differential attacks, and partial cropping. A Dynamic CA–Tent Map (DCA–TM) hybrid chaotic system is designed to overcome periodicity and limited key space issues inherent in conventional chaotic encryption. The permutation stage is refined into coordinate and spatial phases to achieve comprehensive pixel randomization. During diffusion, CA rules are selected dynamically based on the iteration counts of the initial parameters, yielding an adaptive encryption system with a variable key space. Performance evaluations—including Lyapunov exponent tests, bifurcation analysis, information entropy measurement, and pixel correlation assessment—confirm the strong chaotic behavior and high security of the proposed scheme.

1. Introduction

The rapid advancement and widespread deployment of next-generation information technologies—such as big data [1,2,3], neural computing [4,5,6], artificial intelligence [7,8,9], and data networks [10,11,12]—have introduced increasingly complex security challenges. Among various forms of digital content, image data serves as a critical information carrier, and its secure transmission has become a prominent research focus in network communication. Compared with structured textual data, digital images exhibit strong spatial correlation among adjacent pixels and high information redundancy [13,14,15,16]. As a result, conventional text-oriented encryption standards such as AES and DES are inefficient when directly applied to images, often causing substantial ciphertext expansion and residual visual patterns [17,18,19]. Consequently, specialized image encryption techniques have emerged, with chaotic systems being a favored solution due to their unique dynamical properties [20,21,22,23].

Chaotic systems fall into two broad categories: continuous and discrete. Continuous chaotic systems, described by differential equations, are suitable for high-precision simulations [24,25]. Notable examples include the atmospheric convection model proposed by Lorenz [26] and its subsequent Matlab2021b/FPGA implementations [27,28,29,30]. Hyperchaotic systems, a subclass of continuous chaos characterized by multiple positive Lyapunov exponents, can generate highly complex pseudo-random sequences [31,32,33,34].

Discrete chaotic systems, implemented via iterative maps, exhibit comparatively simpler dynamics yet offer high computational efficiency and ease of hardware realization [35,36,37,38,39]. The universality of the logistic map, established by May and Feigenbaum in the 1970s, laid the theoretical groundwork, while its application to real-time image encryption was later demonstrated by Alvarez et al. [40]. The use of chaotic maps for image encryption originated with Matthews’ seminal work in 1989 [41], which proved that the ergodicity of the tent map satisfies Kerckhoffs’s principle. Subsequent research has progressed along two primary directions. The first involves dimension expansion, exemplified by Huang et al.’s composite chaotic system that elevates a 1D logistic map to higher dimensions, increasing the Lyapunov exponent by a factor of 3.2 through phase-space folding [42]. The second direction focuses on hybrid architectures, including Tutueva et al.’s adaptive symmetric chaotic framework [43] (which expands the parameter space by $2^{32}$ times compared to traditional methods) and Zarebnia et al.’s parallel encryption scheme based on Arnold’s cat map [44]. Notably, Fridrich’s investigation of the 2D Baker map revealed that scrambling efficiency improves by over 40% when the chaotic system’s dimension matches that of the image [45]. This body of work underscores a key characteristic of chaotic cryptography: discrete chaotic systems are well-suited for practical image encryption due to their simplicity and low computational overhead [46,47,48].

Cellular automata (CA) have also been validated for cryptographic use since Wolfram demonstrated the pseudo-randomness of Rule 30 in 1986 [49]. Recent advances center on three aspects. First, rule optimization: Nandi et al. showed that alternating Rule 90 and Rule 150 produces sequences that pass all NIST tests [50]. Second, architectural innovation: Chen et al. developed a reversible hybrid CA achieving encryption speeds of 1.2 μs per pixel [51]. Third, system integration: a notable example is the three-stage encryption scheme by Wang et al., which combines DNA encoding, CA, and chaotic mapping and exhibits key sensitivity down to ${10}^{-28}$ [52]. Moreover, the partitioned cellular automata method proposed by Wang et al. markedly improved encryption efficiency [53], and Niyat et al.’s integration of hyperchaotic systems with CA offers a promising approach for color image encryption [54]. Despite these advancements, two limitations persist. First, the use of static CA rules confines the rule-space entropy to at most ${\log }_2\left(256\right)=8$ bits [55,56,57], which is a negligible contribution to the overall key space. Second, the coupling between chaotic systems and CA in existing schemes is predominantly a simple cascade: the CA acts as a post-processor on the output of a chaotic map, without any feedback or dynamic interaction between the two subsystems [58,59,60]. In essence, the chaotic trajectory and the CA evolution remain largely independent, thereby under-utilizing the potential synergistic complexity that could arise from their mutual influence. The present work departs fundamentally from this cascade paradigm. Rather than treating CA as a static downstream component, we embed the CA rule-selection mechanism directly into the iterative dynamics of the tent map. Specifically, the frequency and pattern of CA rule switching are governed in real time by the chaotic state variables themselves. This deep coupling ensures that the system’s trajectory is not merely the output of a chaotic map followed by a deterministic cellular automaton, but a co-evolving hybrid state in which the continuous chaotic phase space and the discrete CA rule space continuously reshape one another.

Regarding security analysis, various attacks on chaotic image encryption algorithms have been reported. Bokhari et al. identified vulnerabilities in hybrid systems through cryptanalysis of quantum chaotic maps and DNA encoding [61], and Feng et al. performed systematic cryptanalysis of schemes relying on pixel-level filtering and DNA diffusion [62]. These studies underscore the necessity of designing more robust hybrid encryption methods.

To address the aforementioned challenges, this work introduces a Dynamic CA–Tent Map (DCA-TM) hybrid system. Its key innovations include: (1) linking the frequency of CA rule switching to the dynamics of the tent map, thereby expanding the key space from $2^8$ to $2^{135}$; (2) designing a maze traversal spatial scrambling algorithm that reformulates image permutation as a graph traversal problem; and (3) constructing a dynamic-rule CA diffusion mechanism that enables linear scalability of both key space and security strength.

The remainder of this paper is organized as follows. Section 2 presents the DCA–TM hybrid chaotic system, detailing its dynamical characteristics—including Lyapunov exponents, bifurcation behavior, and NIST randomness tests—and compares it with classical chaotic systems. Section 3 introduces a breadth-first search (BFS)-based pixel scrambling method that globally randomizes pixel positions through simulated maze traversal, along with an analysis of its resistance to statistical attacks. Section 4 describes the three-stage encryption process (coordinate scrambling, spatial scrambling, and diffusion), covering the Arnold transform, maze traversal scrambling, dynamic CA diffusion, and reversible decryption. Section 5 validates the algorithm’s security and robustness through key space evaluation, correlation analysis, information entropy tests, and assessments of resilience to noise and cropping attacks, with comparisons to existing schemes.

2. A Novel Chaotic System Based on Cellular Automata and Tent Map

Chaos refers to a class of deterministic yet seemingly random dynamical behaviors observed in many natural systems. In this work, chaotic mappings are defined as nonlinear dynamical systems exhibiting extreme sensitivity to initial conditions. Prior research demonstrates that efficient encryption systems can be constructed from canonical chaotic maps, notably the tent map and elementary cellular automata (ECA). This section first analyzes the dynamical properties of the tent map and ECA, then it proposes a new chaotic system built through nonlinear coupling. The chaotic nature of the proposed system is rigorously validated via numerical experiments.

2.1. Tent Map

The tent map was first proposed by Soviet mathematician A.N. Sharkovsky in the 1960s during his research on dynamical systems, and it was later extensively analyzed and popularized in chaos theory by American mathematician Robert L. Devaney and others. Its name derives from the tent-like shape of its function graph. When the parameter is equal to 2, the map exhibits fully developed chaos, making it a classic model for studying sensitivity to initial conditions and ergodicity. Its simple piecewise linear form has been widely applied in pseudo-random number generation and encryption algorithms, serving as a quintessential example of “simple systems producing chaotic behavior.”

The standard form of the tent map is:

$$T_{\mu }\left(x\right)=\left\{\begin{array}{cc}\mu x,\hfill & 0\le x\le {\displaystyle \frac{1}{2}},\hfill \\ \mu (1-x),\hfill & {\displaystyle \frac{1}{2}}<x\le 1.\hfill \end{array}\right.$$

(1)

2.2. Cellular Automata

Cellular Automata (CA), originally proposed by John von Neumann and Stanislaw Ulam in the 1940s, were initially conceived to model biological self-replication. This computational framework consists of four fundamental components: a discrete lattice of cells, a finite set of states, a neighborhood definition, and a transition rule. John Conway’s Game of Life (1970) later demonstrated how simple local rules could generate complex emergent behaviors. Stephen Wolfram [63] systematically classified CA dynamics into four categories and established the Turing completeness of certain CA variants. As discrete dynamical systems defined in space, time, and state, CA exhibit rich global behaviors through localized interactions, making them widely applicable in physics (e.g., fluid dynamics), biology (e.g., morphogenesis), and social systems (e.g., traffic flow modeling). In cryptography, CA’s parallel computability and sensitivity to initial conditions enable efficient encryption schemes. Within complexity science, CA serve as essential tools for studying self-organization, edge-of-chaos phenomena, and other nonlinear dynamics. Over decades of development, CA theory has profoundly influenced interdisciplinary research, bridging mathematics, computer science, and complex systems studies.

In elementary cellular automata, the state update of each cell is determined by its own state and the states of its neighbors at the previous time step, and the local transition function can be expressed in the following mathematical form:

$$S_i^{(t+1)}=f\left(S_{i-1}^t,S_i^t,S_{i+1}^t\right)$$

(2)

Here, $S_i^t$ denotes the state of the cell at position i at time step t, and f represents the local rule of the cellular automaton. For an elementary cellular automaton, the neighborhood consists of three cells, each with only two possible states. Thus, there are $2^3=8$ possible input state combinations. Since each input can produce one of two possible output states, there are a total of $2^8=256$ possible rules. The rule number is determined by the decimal equivalent of the binary sequence representing the output states.

Table 1. State transition table for Rule 75.

${\mathit{S}}_{\mathit{i}-1}^{\mathit{t}}{\mathit{S}}_{\mathit{i}}^{\mathit{t}}{\mathit{S}}_{\mathit{i}+1}^{\mathit{t}}$	${\mathit{S}}_{\mathit{i}}^{\mathit{t}}$	${\mathit{S}}_{\mathit{i}-1}^{\mathit{t}}{\mathit{S}}_{\mathit{i}}^{\mathit{t}}{\mathit{S}}_{\mathit{i}+1}^{\mathit{t}}$	${\mathit{S}}_{\mathit{i}+1}^{\mathit{t}}$
111	0	011	1
110	1	010	0
101	0	001	1
100	0	000	1

shows the state transition table corresponding to Rule 75.

2.3. Dynamic CA–Tent Map

This work proposes a novel chaotic system (DCA–TM) based on the integration of cellular automata and tent mapping. The system significantly enhances the performance of conventional tent mapping through three key innovations. Firstly, it introduces CA’s local evolution rules and modified Logistic transformation to achieve dual nonlinear processing of state variables. Secondly, it replaces the fixed parameter $\mu$ with a dynamic parameter p and directly incorporates it into the piecewise conditions of the mapping. Finally, through designed coupling coefficients and cross-feedback mechanisms, it constructs a two-dimensional phase space with excellent ergodicity. The core formula of the DCA–TM system is presented as follows:

$$\begin{array}{cc}\hfill x_{n+1}& =\left\{\begin{array}{cc}{\displaystyle \frac{p}{6}}·LM\left(CA(x_n,i)\right)+y_n,\hfill & \mathrm{if}{x}_n<p\hfill \\ {\displaystyle \frac{p}{4}}·LM\left(CA(y_n,i)\right)+x_n,\hfill & \mathrm{if}{x}_n\ge p\hfill \end{array}\right.\hfill \\ \hfill y_{n+1}& =\left\{\begin{array}{cc}{\displaystyle \frac{p}{4}}·LM\left(CA(x_n,i)\right)+y_n,\hfill & \mathrm{if}{x}_n<p\hfill \\ {\displaystyle \frac{p}{6}}·LM\left(CA(y_n,i)\right)+x_n,\hfill & \mathrm{if}{x}_n\ge p\hfill \end{array}\right.\hfill \end{array}$$

(3)

The system state variables $x_n$ and $y_n$ represent the two-dimensional state values at the n-th iteration of the chaotic system, with their values constrained to the interval $[0,1]$, forming the basis of the two-dimensional phase space. The parameter p serves as the key control parameter, which not only replaces the fixed parameter $\mu$ in Equation (4) but is also directly embedded in the piecewise conditions ($x_n<p$ or $x_n\ge p$) to achieve dynamic regulation. CA denotes the evolution rules of cellular automata, whose output depends on both the current state value ($x_n$ or $y_n$) and the iteration count i of the elementary cellular automaton. The operator $LM$ represents a fractal-enhanced Logistic mapping, defined as:

$$L{M}_{\mathrm{fractal}}\left(x\right)={\mu }_{\mathrm{fractal}}\left(x\right)·(3x+1)·x·(1-x),$$

(4)

where the modulation parameter ${\mu }_{\mathrm{fractal}}\left(x\right)$ is given by

$${\mu }_{\mathrm{fractal}}\left(x\right)=1.85\times \left(1+{\displaystyle \frac{sin\left(2\pi ·\Psi \left(x\right)\right)}{4}}\right),$$

(5)

and $\Psi \left(x\right):[0,1]\to [0,1]$ is a fractal localization function defined by the pseudo-code in Algorithm 1. This fractal structure ensures that even tiny differences in the input x lead to significantly different outputs, effectively eliminating sparse orbital regions that may appear when the control parameter p is small, while preserving the original system architecture. The fractal approach follows the methodology introduced in earlier works on right-hand side fractal functions in chaotic systems [64]. The CA alternates between two rules: Rule 30 and Rule 150, with the rule switching every ten iterations of the chaotic system. The generation process of the output sequence for the DCA–TM chaotic system is shown in Figure 1.

Algorithm 1 Fractal localization function $\Psi \left(x\right)$
Input: $x\in [0,1]$, depth d (e.g., $d=10$)
Output: $\Psi \left(x\right)\in [0,1]$
1:	$step\leftarrow 2^{-d}$
2:	$k\leftarrow \lfloor x/step\rfloor$ {Index of subinterval}
3:	$\Psi \left(x\right)\leftarrow k\times step$ $\Psi \left(x\right)$

2.3.1. Bifurcation Analysis

The bifurcation diagram constitutes an essential analytical tool in nonlinear dynamics, enabling systematic examination of chaotic system properties. As shown in Figure 2, it provides visual representation of parameter-dependent system behaviors while distinctly illustrating both stability conditions and chaotic regime distributions. Our analysis of the Dynamic CA–Tent Map (DCA–TM) system reveals that the high density of chaotic trajectories and their uniform phase-space distribution (see Figure 2) collectively demonstrate the robust chaotic characteristics and dynamical stability inherent to this proposed system.

2.3.2. Lyapunov Exponent Comparison

Figure 3 presents a comparative analysis of Lyapunov exponent (LE) metrics between DCA–TM and several conventional chaotic systems. The results demonstrate that DCA–TM achieves significantly higher LE values, indicating superior chaotic sensitivity and enhanced dynamic complexity compared to benchmark systems. This quantitative evidence confirms the improved chaotic characteristics of our proposed system.

2.3.3. NIST Test

The NIST test suite comprises 15 comprehensive tests, requiring all test results to be greater than or equal to 0.01. It is designed to evaluate the randomness quality of binary sequences generated by hardware or software, regardless of their length. Within the context of chaotic systems, these tests play a critical role in assessing the performance of random number generators, particularly in fields such as cryptography and information security. By passing these tests, the system effectively demonstrates that the generated data exhibits high randomness and unpredictability.

As illustrated in

Table 2. NIST test structure for sequence X and sequence Y.

Test Method	X	Y	Result
Single-bit frequency test	0.3381	0.3019	Pass
Block frequency test	0.6401	0.5967	Pass
Runs test	0.2700	0.2901	Pass
Longest runs-of-ones in a block test	0.3216	0.3508	Pass
Binary matrix rank test	0.0550	0.0620	Pass
DFT test	0.2528	0.2211	Pass
Non-overlapping template matching test	0.1212	0.1672	Pass
Overlapping template matching test	0.3670	0.3351	Pass
Maurer’s universal statistical test	0.6889	0.6773	Pass
Linear complexity test	0.6699	0.6096	Pass
Serial test	0.7645	0.6042	Pass
ApEn test	0.6140	0.5974	Pass
Cusum test	0.6476	0.7006	Pass
Random excursion test	0.6614	0.5963	Pass
Random excursions variant test	0.9902	0.9908	Pass

, the system successfully passed all 15 tests, confirming that its chaotic mechanism is capable of producing data with strong randomness.

2.3.4. 0–1 Test

The 0–1 test for chaos is a binary test that distinguishes between regular and chaotic dynamics in deterministic systems. Given a scalar time series ${\left\{\varphi \left(j\right)\right\}}_{j=1}^N$, the test computes a value K close to 0 for regular dynamics and close to 1 for chaotic dynamics. For a random constant $c\in (0,\pi )$, we define translation components:

$$\begin{array}{cc}\hfill D_c\left(n\right)=& {\displaystyle \frac{1}{N}}\sum _{j=1}^{N-n}\left[{\left(p_c(j+n)-p_c\left(j\right)\right)}^2+{\left(q_c(j+n)-q_c\left(j\right)\right)}^2\right]\hfill \\ \hfill & -{\left({\displaystyle \frac{1}{N}}\sum _{j=1}^N\varphi \left(j\right)\right)}^2{\displaystyle \frac{1-cos\left(nc\right)}{1-cos\left(c\right)}},\hfill \end{array}$$

(6)

and its growth rate with respect to n yields the correlation coefficient $K_c$. The final test outcome K is the median of $K_c$ over many randomly chosen c (typically $c\in (\pi /5,4\pi /5)$).

We applied the 0–1 test to the pseudo-random sequences generated by the DCA–TM system. Specifically, we used the x-component of the chaotic output (after discarding a sufficient number of initial transients) as the input series $\varphi \left(j\right)$ with length $N={10}^5$. The median value of $K_c$ over 100 randomly chosen c was found to be $K=0.996$, which is extremely close to 1. This result confirms the strongly chaotic nature of the DCA–TM system and is consistent with the high Lyapunov exponents and the successful NIST tests reported in previous subsections, further validating the excellent randomness of the generated sequences.

3. Maze Traversal-Based Spatial Scrambling Algorithm

The second stage of the encryption process employs a spatial scrambling algorithm based on maze traversal. This algorithm rearranges the pixel matrix by simulating navigation through a maze, thereby achieving spatial scrambling of the image. Consider an $m\times n$ image matrix $P^{\prime }$ derived from the original image P, as shown in Figure 4.

Step 1: Create a Boolean access marker matrix A of the same dimensions as the original image, initialized to 0, to track whether each coordinate has been visited.(see Figure 5).

Create coordinate sequence matrix $\mathbf{B}$ ($N\times 2$, N: total pixels) where $(X_m,Y_n)$ are coordinates to be added, storing traversed coordinate pairs in order; initialized as empty. Create an encrypted image matrix C, with the same dimensions and data type as the original image, initialized as a zero matrix, used to store the encryption results.

Step 2: Select the top-left corner $(1,1)$ of the image matrix $P^{\prime }$ as the traversal starting point. Mark this coordinate as visited and store it in the first row of matrix B. Define the four-neighborhood direction vectors: $[1,0]$ (down), $[-1,0]$ (up), $[0,1]$ (right), and $[0,-1]$ (left). Using a breadth-first search strategy, starting from the current coordinate, examine adjacent pixels according to the predefined direction order. For each valid and unvisited neighboring coordinate, update the access marker and append the coordinate to matrix B. Repeat this process until matrix B contains all image coordinates.

(1) Visit(1,1), mark(1,1) as visited (Figure 6).

(2) Start from (1,1). Check neighbors in order: down (2,1)— valid and unvisited, add to B; up (0,1)—out of bounds; right (1,2)—valid and unvisited, add to B; left (1,0)—out of bounds (see Figure 7 and Figure 8).

(3) Start from (2,1). Check adjacent pixels. Down to (3,1)—within bounds and unvisited, add to B; up to (1,1)—already visited (skip); right to (2,2)—within bounds and unvisited, add to B; left—out of bounds (invalid) (Figure 9 and Figure 10).

(4) Start from (1,2). Check adjacent pixels. Down to (2,2)—already visited (skip); up—out of bounds (invalid); right to (1,3)—within bounds and unvisited, add to B; left to (1,1)—already visited (skip) (Figure 11 and Figure 12).

(5) Follow this procedure until all elements in A become 1, then terminate the process, obtaining the final matrices A and B (Figure 13 and Figure 14).

Step 3: Flatten the original image pixels into vector $\mathbf{V}$ in row-major order:

$$\mathbf{V}=\left[67,79,83,112,129,134,168,179,182\right]$$

Step 4: Using the coordinate sequence stored in matrix B, assign the i-th element of vector V to the position specified by $B(i,:)$ in matrix C, i.e., $C\left(B\right(i,1),B(i,2\left)\right)=V\left(i\right)$ for $i\in [1,N]$. The filling process is outlined in Algorithm 2. The final encrypted image C is shown in Figure 15.

The final encrypted image C is:

Algorithm 2 Pixel Rearrangement Process
Input: Original image $image\left[M\right]\left[N\right]\left[C\right]$
Input: Coordinate sequence $coord\_sequence[M\times N]\left[2\right]$
Output: Encrypted image $encrypted\_image\left[M\right]\left[N\right]\left[C\right]$
1:	for $channel=1$ to C do
2:	for $idx=1$ to $M\times N$ do
3:	$src\_row\leftarrow \lfloor (idx-1)/N\rfloor +1$
4:	$src\_col\leftarrow (idx-1)\mathrm{mod}N+1$
5:	$new\_row\leftarrow coord\_sequence\left[idx\right]\left[1\right]$
6:	$new\_col\leftarrow coord\_sequence\left[idx\right]\left[2\right]$
7:	$encrypted\_image[new\_row][new\_col]\left[channel\right]\leftarrow image[src\_row][src\_col]\left[channel\right]$
8:	end for
9:	end for

4. Encryption and Decryption Algorithm

Based on the pseudo-random sequence generated by the chaotic system described above, this work abandons the traditional scrambling–diffusion encryption mechanism and adopts an encryption structure of coordinate scrambling–spatial scrambling–diffusion. Three encryption algorithms are designed: an Arnold-based coordinate scrambling method, a maze traversal-based scrambling method, and a CA matrix-based diffusion method. The flowchart of the encryption algorithm is shown in the Figure 16.

4.1. Arnold-Based Coordinate Scrambling

This work employs an Arnold transform-based scrambling method in the first step of the encryption process to perform coordinate scrambling on the original image. For each pixel in the original image, specific mathematical transformations are applied to its coordinates to disrupt the spatial structure of the image. The transformation formulas are as follows:

$$\left\{\begin{array}{c}\widehat{x}=(x+by)\mathrm{mod}M\hfill \\ \widehat{y}=(rqx+(1+brq)y)\mathrm{mod}N\hfill \end{array}\right.$$

(7)

where M and N are the width and height of the image, respectively, b and r are arbitrary integers, and $q=N/\gcd (M,N)$, with gcd being the greatest common divisor. After coordinate scrambling, the originally meaningful image is transformed into a meaningless one, achieving preliminary information hiding.

Step 1: Let the original image size be $M\times N$ (M is the width, N is the height). Select integers b (horizontal stretching factor) and r (vertical coupling coefficient), and define the auxiliary parameter $q=N/\gcd (M,N)$.

Step 2: For any pixel $(x,y)\in [0,M-1]\times [0,N-1]$, its scrambled coordinates $(\widehat{x},\widehat{y})$ satisfy Equation (7).

Step 3: Move the original pixel $(x,y)$ to the new position $(\widehat{x},\widehat{y})$.

Invertibility proof:The transformation can be written in matrix form as

$$\left[\begin{array}{c}\widehat{x}\\ \widehat{y}\end{array}\right]=\left[\begin{array}{cc}1& b\\ rq& 1+brq\end{array}\right]\left[\begin{array}{c}x\\ y\end{array}\right](\mathrm{mod}M,N)$$

(8)

where the modular operations are applied separately: $\widehat{x}$ modulo M, $\widehat{y}$ modulo N. The determinant of the coefficient matrix is

$$\det =1·(1+brq)-b·\left(rq\right)=1+brq-brq=1.$$

(9)

Since the determinant is 1, the matrix is invertible over the integers. The inverse transformation is given by

$$\left[\begin{array}{c}x\\ y\end{array}\right]=\left[\begin{array}{cc}1+brq& -b\\ -rq& 1\end{array}\right]\left[\begin{array}{c}\widehat{x}\\ \widehat{y}\end{array}\right](\mathrm{mod}M,N).$$

(10)

Thus, the coordinate scrambling step is strictly bijective and fully reversible.

4.2. Spatial Scrambling via Maze Traversal

In the second step of the encryption process, this work employs a maze traversal-based spatial scrambling algorithm. This algorithm rearranges the pixel matrix of the image by simulating the process of maze traversal, thereby achieving spatial scrambling of the image.

Step 1: Initialize three matrices A, B, and S. Matrix A is used to record visited coordinates, ensuring each coordinate is accessed only once. Matrix B stores the order of the visited coordinates, serving as the basis for subsequent pixel rearrangement. Matrix S is a zero matrix with the same dimensions as the original image, used to store the encrypted pixel values.

Step 2: Starting from the top-left coordinate $(1,1)$ of the image, traverse the pixel matrix in a maze-like manner using direction vectors (down, up, right, left). During traversal, record each accessed coordinate in matrix B.

Step 3: After traversal is complete, sequentially copy the pixel values from the original image to the corresponding new coordinates in matrix S according to the order recorded in matrix B, thereby achieving spatial rearrangement of the pixels.

4.3. CA Matrix-Based Diffusion

This work employs a diffusion method based on a cellular automata (CA) matrix in the third step of the encryption process. This method utilizes a pseudo-random matrix derived from a chaotic system to perform row-by-row and column-by-column diffusion processing on the pixel values of the image. Assuming the image has M rows and N columns, the specific implementation process is as follows:

Step 1: Extract pseudo-random numbers sequentially from the pseudo-random matrices A and B obtained from the chaotic system, and arrange them in row-major order to form an M × N matrix S.

Step 2: Starting from the first row, process the pixel value in the second column of the first row by performing a bitwise XOR operation with the pixel value in the first column. Then, perform another bitwise XOR operation on the result with the value at the first row and first column of matrix S. This yields a new pixel value, which is temporarily stored as the updated value for the second column of the first row (to be used in subsequent steps).

Step 3: Continue processing the pixel in the third column of the first row. Perform a bitwise XOR operation with the pixel value in the second column (i.e., the temporary value computed in the previous step, which now serves as the “new” pixel value for the second column), followed by a bitwise XOR operation with the value at the first row and second column of matrix S. Assign the resulting value to the pixel in the second column of the first row.

Step 4: Repeat this process column by column for the pixels in the first row until the pixel in the (N − 1)-th column of the first row is updated. For the pixel in the N-th column of the first row, perform a bitwise XOR operation with the constant 255 and the value at the first row and N-th column of matrix S, then assign the result to the pixel in the N-th column of the first row.

Step 5: After completing the processing of the first row, apply the same steps to the second row through the M-th row. That is, for each row, start from the second column and sequentially perform bitwise XOR operations with the pixel value from the previous column and the corresponding value in matrix S until the last pixel of the row is processed.

The diffusion flowchart is shown in Figure 17.

For clarity and to facilitate independent implementation, the complete encryption procedure is summarized in Algorithm 3. The algorithm integrates the three phases described above—coordinate permutation, maze traversal spatial scrambling, and CA matrix diffusion—into a unified pipeline. It takes the plaintext image P and the secret key $K=(x_0,y_0,p)$ as inputs, and outputs the ciphertext image C. The corresponding decryption procedure executes the exact inverse of each phase, relying on the identical chaotic keystream regenerated from the shared secret key.

Algorithm 3 Complete Encryption Procedure
Input: Plaintext image P of size $M\times N$, secret key $K=(x_0,y_0,p)$
Output: Ciphertext image C of size $M\times N$
1:	// Phase 0: Initialization
2:	Generate chaotic sequences $\left\{x_n\right\},\left\{y_n\right\}$ by iterating DCA–TM (Equation (3)) with initial states $(x_0,y_0,p)$.
3:	Discard first ${10}^3$ iterations to eliminate transient effects.
4:	Extract required parameters from chaotic sequences as needed (e.g., Arnold coefficients $b,r$, CA iteration count T).
5:	// Phase 1: Coordinate Permutation (Arnold Transform)
6:	Compute $q\leftarrow N/\gcd (M,N)$.
7:	for each pixel at coordinate $(x,y)$ in P do
8:	$\widehat{x}\leftarrow (x+b·y)\mathrm{mod}M$
9:	$\widehat{y}\leftarrow (r·q·x+(1+b·r·q)·y)\mathrm{mod}N$
10:	$P^{\prime }(\widehat{x},\widehat{y})\leftarrow P(x,y)$
11:	end for
12:	// Phase 2: Spatial Permutation (Maze Traversal)
13:	Generate coordinate sequence $\mathbf{B}$ of length $M\times N$ using maze traversal (BFS on $M\times N$ grid).
14:	Flatten $P^{\prime }$ into vector $\mathbf{V}$ in row-major order.
15:	for $i=1$ to $M\times N$ do
16:	$(row,col)\leftarrow \mathbf{B}\left(i\right)$
17:	$P^{″}(row,col)\leftarrow \mathbf{V}\left(i\right)$
18:	end for
19:	// Phase 3: Diffusion (CA Matrix XOR)
20:	Generate pseudo-random matrix S of size $M\times N$ from chaotic sequences $\left\{x_n\right\}$.
21:	for $i=1$ to M do
22:	for $j=2$ to N do
23:	$P^{″}(i,j)\leftarrow P^{″}(i,j)\oplus P^{″}(i,j-1)\oplus S(i,j)$
24:	end for
25:	end for
26:	for $j=1$ to N do
27:	for $i=2$ to M do
28:	$P^{″}(i,j)\leftarrow P^{″}(i,j)\oplus P^{″}(i-1,j)\oplus S(i,j)$
29:	end for
30:	end for
31:	$C\leftarrow P^{″}$ C

The decryption procedure executes the exact inverse of each phase, using the same chaotic keystream generated from the shared secret key.

5. Experimental Results and Performance Analysis

5.1. Encryption and Decryption Results

The simulation results of the encryption scheme are shown in Figure 18: (a)–(c) represent the original unencrypted images Peppers, Baboon, and Airplane; (d)–(f) are the corresponding encrypted noise-like images; (g)–(i) show the decrypted images, respectively. As can be observed, the encrypted images become completely unrecognizable noise patterns, while the decrypted images are visually indistinguishable from the original ones. Moreover, the decrypted images have essentially restored the original pixel information within numerical precision limits.

5.2. Key Space and Sensitivity Analysis

The key space, representing the total number of distinct keys that can be used in an encryption scheme, is a fundamental metric for evaluating its resistance to brute-force attacks. In the proposed encryption scheme, the total key space is determined by the combination of the sensitive parameters of the chaotic system and the initial conditions governing the cellular automata (CA). A rigorous estimation must consider the finite precision of physical implementations and the interdependence of key components.

The key space is derived from the Cartesian product of the following independent factors:

Chaotic parameter space: The system utilizes a tent map, which is highly sensitive to its initial condition $x_0$ and control parameter $\mu$. In a practical digital computer environment with double-precision floating-point representation (64-bit double format according to the IEEE 754 standard) [65], the valid precision for real numbers is approximately $2^{-52}$ for the mantissa. This limits the number of distinct states that $x_0$ and $\mu$ can assume. However, considering the entire 64-bit representation (including sign and exponent) for key space calculation, each parameter can be considered to have $2^{64}$ possible values. Since both $x_0$ and $\mu$ are used as keys, the effective key space contributed by the chaotic map is $2^{64}\times 2^{64}=2^{128}$.

CA rule-switching dynamics: The system supports k available CA rules. Importantly, the switching sequence is not an independent key but is deterministically driven by the chaotic sequences generated from the tent map. Therefore, the rule combination space does not independently multiply the total entropy. Instead, the number of possible switching sequences is inherently bounded by the number of possible chaotic sequences ($2^{128}$). The specification of the rule set (e.g., which k rules are used) can be considered part of the algorithm’s configuration. For the key space estimation, we consider the uncertainty in the switching pattern as fully embedded within the sensitivity of the initial chaotic parameters. If we were to treat the switching pattern as a separate variable (e.g., a combination of m selections from k rules), its theoretical size would be $k^m$. However, since this pattern is purely deterministic based on $x_0$ and $\mu$, it does not add extra entropy beyond the chaotic parameter space. To avoid overestimating the key space, we do not multiply the total by $k^m$ as an independent factor, but rather acknowledge that the chaotic parameters control this complexity.

Variable iteration space: The number of CA iterations T is dynamically determined by a segment of the chaotic sequence within a predefined range (e.g., $T\in [T_{\min },T_{\max }]$). This introduces additional uncertainty because the exact number of rounds is unknown to an attacker without the key. Assuming T is an integer derived from the chaotic sequence, the number of possible values it can take is $(T_{\max }-T_{\min }+1)$. The entropy contributed by this factor is ${log}_2(T_{\max }-T_{\min }+1)$ bits, resulting in a space of $2^{{log}_2(T_{\max }-T_{\min }+1)}$.

Based on the above analysis, the total effective key space K is the product of the independent chaotic parameter space and the iteration space:

$$K=2^{128}\times 2^{{log}_2(T_{\max }-T_{\min }+1)}.$$

(11)

In our specific implementation, we utilize two CA rules (Rule 30 and Rule 150) switched by the chaotic sequence. The iteration count T is confined to the interval $[50,150]$. Therefore, the total key space is:

$$K=2^{128}\times 2^{{log}_2(150-50+1)}=2^{128}\times 2^{{log}_2\left(101\right)}.$$

(12)

Since $2^6=64$ and $2^7=128$, ${log}_2\left(101\right)\approx 6.66$. To provide a conservative estimate in terms of bit length, we can state the key space is approximately:

$$K\approx 2^{128}\times 2^{6.66}=2^{134.66}\approx 2^{135}.$$

(13)

This key space ($2^{135}$) is sufficiently large to resist exhaustive brute-force attacks with current computational capabilities. It is important to note that the rule-switching mechanism, while deterministic, ensures that the encryption process is highly complex and non-linear, and its full entropy is captured by the sensitivity of the initial chaotic parameters.

$$Key1=0.525000000000000000$$

(14)

$$Key2=0.525000000000000001$$

(15)

Here, Key1 is the correct key value, and Key2 is a slightly modified key. These two keys will then be used to decrypt the encrypted image. The results are shown in Figure 19: (a) shows the image decrypted with the correct key, while (b) shows the image decrypted with the slightly modified Key2. It can be seen from the figures that the image encryption algorithm proposed in this chapter is highly sensitive to the key.

5.3. Correlation Analysis

Randomly select 1000 pairs of adjacent pixels in the horizontal, vertical, and diagonal directions from the plaintext image and the target encrypted image, and calculate the correlation between adjacent pixels. The smaller this value, the better the encryption effect.

As can be seen from

Table 3. Correlation analysis results.

	Original Image			Encrypted Image
	Hori.	Vert.	Diag.	Hori.	Vert.	Diag.
Proposed	0.9900	0.9925	0.9964	−0.0003	0.0095	0.0025
Firdous et al. [66]	0.9663	0.9789	0.9843	−0.0036	−0.00028	−0.0021
Pak & Huang [67]	0.9239	0.9567	0.8888	−0.0038	−0.0026	0.0017
Zou et al. [68]	0.9765	0.9606	0.9356	0.0004	−0.0033	−0.0070
Zheng & Hu [69]	0.9854	0.9718	0.9554	0.0077	0.0053	0.0003
Song et al. [70]	0.9556	0.9326	0.9183	−0.0106	0.0137	0.0152
Yavuz [71]	0.9861	0.9727	0.9602	0.0026	−0.0095	0.0032
Zhou [72]	0.9425	0.9794	0.9482	0.0105	−0.0025	0.0003

, the image encryption method based on chaotic systems in this example exhibits significantly lower correlation between adjacent pixels after encryption compared to other designs in the literature, with values almost approaching zero, demonstrating superior encryption performance.

5.4. Entropy Analysis

Entropy can measure the distribution of image grayscale values. The more uniform the grayscale distribution, the higher the entropy value. It serves as an indicator to evaluate the performance of image encryption—the closer this value is to 8, the better the encryption effect.

As shown in

Table 4. Entropy analysis results.

	Peppers	Airplane	Baboon	Average
Proposed	7.9997	7.9998	7.9999	7.9998
Firdous et al. [66]	7.9970	7.9973	7.9975	7.9973
Zou et al. [68]	7.9993	7.9972	7.9975	7.9978
Zheng & Hu [69]	7.9993	7.9992	7.9992	7.9993
Song et al. [70]	7.9991	7.9994	7.9998	7.9994
Yavuz [71]	7.9992	7.9975	7.9993	7.9988

, compared with other schemes in the literature, the chaotic system-based image encryption method in this embodiment achieves an entropy value closest to 8, demonstrating its superior encryption performance.

5.5. Ability of Resisting Noise and Data Loss

Salt-and-pepper noise attack is a common form of noise interference in digital image processing. In this attack, certain pixels in the image are randomly selected and set to either the minimum or maximum pixel value, thereby introducing black and white speckles into the image.

The results of salt-and-pepper noise attack are shown in Figure 20: (a) original image; (b) encrypted image with 0.05 density noise attack; (c) encrypted image with 0.1 density noise attack; (d) decrypted image of (a); (e) decrypted image of (b); (f) decrypted image of (c). As demonstrated by the noise attack results, the proposed encryption scheme can effectively reconstruct the original image information even under high-density salt-and-pepper noise interference.

Gaussian noise is introduced by adding random noise following a Gaussian distribution to the image. The noise intensity can be controlled by adjusting the standard deviation (sigma) of the Gaussian distribution—the larger the sigma value, the more severe the noise degradation in the image.

The Gaussian noise attack results are illustrated in Figure 21: (a) decrypted image of the original image; (b) decrypted image after 0.01 Gaussian noise interference on the encrypted image; (c) decrypted image after 0.05 Gaussian noise interference on the encrypted image. As evidenced by the Gaussian noise attack results, the decrypted images maintain high visual recognizability and structural integrity even under relatively strong Gaussian noise interference.

A cropping attack refers to an adversarial scenario where an attacker extracts a partial region from an encrypted image, attempting to analyze or process this cropped segment to obtain valuable information. This attack exploits potential vulnerabilities in the local region processing of image encryption algorithms. By compromising image integrity and altering pixel distribution structures, the attack impacts decryption effectiveness, leading to inter-block synchronization information loss during decryption. Consequently, the decrypted image may exhibit localized distortions or irreversible reconstruction failures.

The cropping attack results are shown in Figure 22: (a) encrypted image with 1/16 area cropped; (b) encrypted image with 1/8 area cropped; (c) encrypted image with 1/4 area cropped; (d) decrypted image of (a); (e) decrypted image of (b); (f) decrypted image of (c). The results demonstrate that the decrypted images reconstructed from attacked encrypted versions exhibit neither localized distortions nor reconstruction failures. This confirms the scheme’s strong resistance against cropping attacks.

Chosen-plaintext attack (CPA) is an attack model wherein the adversary, who possesses knowledge of the encryption algorithm, can choose arbitrary plaintexts and obtain their corresponding ciphertexts. The goal of the adversary is to derive the secret key, despite having this capability. Under a chosen-plaintext attack (CPA) scenario, when fully black or fully white images are selected as the plaintext, the resulting ciphertext images exhibit the following characteristics: they appear random, their histograms remain uniform, and their information entropy is close to 8. These properties demonstrate the algorithm’s capability of withstanding chosen-plaintext attacks. The CPA results are shown in Figure 23: (a) original image; (b) the encrypted image under CPA; (c) decrypted image. The experimental results indicate that the ciphertexts of fully black and white images appear random, with uniform histograms and information entropy values of 7.99928 and 7.99940, both close to 8. These results confirm that all evaluated metrics meet the required security criteria, proving the algorithm’s resistance to CPA.

The degree of difference between two ciphertext images can be quantitatively measured using two indicators: the Number of Pixels Change Rate (NPCR) and the Unified Average Change Intensity (UACI). These two indicators are defined as the normalized L0 and L1 norm differences between the two images, respectively, with the specific calculation formulas shown in Equations (8) and (9). In these equations, C1 and C2 represent the two ciphertext images obtained by encrypting the original plaintext image and the modified plaintext image, respectively. M and N denote the dimensions of the images, and the sign(·) function returns 0 if its argument is 0, and 1 otherwise.

$$\mathrm{NPCR}={\displaystyle \frac{{\sum }_{i=1}^M{\sum }_{j=1}^N|sign(C_1(i,j)-C_2(i,j))|}{M\times N}}\times 100.$$

(16)

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

(17)

Theoretically, the NPCR value is approximately 99.6024, and the UACI value is close to 33.4635.

Table 5. NPCR and UACI comparison for Peppers image.

	Proposed	Ref. [73]	Ref. [74]	Ref. [75]	Ref. [76]
NPCR	99.60%	99.61%	99.62%	99.17%	99.63%
UACI	33.46%	32.07%	33.26%	33.59%	33.52%

presents a comparison of NPCR and UACI values for the Peppers image using different encryption methods.

5.6. Time Complexity Analysis

The time consumption of the proposed algorithm primarily appears in the following three phases:

Phase 1: Coordinate permutation (Arnold transformation). In this stage, coordinate transformation is performed for each pixel of the original image, necessitating traversal of all pixel positions. The time complexity is $O(M\times N)$, where M and N are the width and height of the image, respectively.

Phase 2: Maze traversal-based spatial permutation. This stage rearranges pixel positions using a breadth-first search strategy. As described in Section 3, it requires initializing the access marker matrix A ($M\times N$) and the coordinate sequence matrix B ($MN\times 2$), and performing neighborhood detection and enqueue operations for each pixel. The time complexity of a breadth-first search on a grid graph is $O(V+E)$, where $V=MN$ is the number of nodes, and $E\approx 4MN$ is the number of edges (four-neighbor connectivity). Therefore, the time complexity of this stage is $O\left(MN\right)$.

Phase 3: CA matrix-based diffusion. This stage processes the permuted image with XOR diffusion in both row-wise and column-wise directions. As described in Section 4.3, it requires traversing all pixels of the image, with each pixel undergoing two XOR operations (one with the previous pixel and one with the CA matrix value). The time complexity is $O(2\times M\times N)=O\left(MN\right)$.

In summary, the overall time complexity of the encryption algorithm is $O(3\times M\times N)$, which is linearly related to the total number of image pixels. It should be noted that the keystream generation phase (chaotic sequence pre-iteration) requires only constant time overhead, which is negligible.

5.7. Discussion of Experimental Findings

The experimental results presented above collectively validate the security enhancements introduced by the proposed three-phase architecture and, in particular, the dynamic CA rule-switching mechanism. The near-zero adjacent-pixel correlation coefficients (Table 3) demonstrate that the maze traversal spatial permutation effectively disrupts the strong spatial continuity inherent in natural images, while the XOR-chain diffusion further decorrelates neighboring pixels by propagating modifications across both rows and columns. The information entropy values exceeding 7.9997 (Table 4) confirm that the DCA–TM keystream possesses sufficient randomness to flatten the grayscale histogram completely; unlike static CA configurations, the deterministic yet chaotic alternation between Rule 30 and Rule 150 prevents the emergence of any recurring statistical patterns in the ciphertext. Furthermore, the retained visual recognizability under high-density noise and substantial cropping (Figure 20, Figure 21 and Figure 22) is a direct consequence of the global dispersion property conferred by the maze traversal: each plaintext pixel contributes to multiple spatially distant ciphertext positions, so that localized corruption is effectively averaged out during decryption. Finally, the NPCR and UACI metrics (Table 5) quantitatively validate the strong plaintext sensitivity of the scheme, which arises from the CA diffusion phase where a single-pixel alteration cascades through the entire image via the XOR chain, producing the avalanche effect characteristic of a secure cryptosystem. In summary, the dynamic integration of CA rule switching with the tent map not only expands the key space but also enhances diffusion uniformity and robustness against statistical and physical attacks, thereby accounting for the superior performance metrics observed across all the evaluations.

6. Conclusions

This study addresses the inherent limitations of conventional chaotic encryption methods—including periodicity, restricted key space, and insufficient attack resistance—by proposing an image encryption algorithm that integrates cellular automata with a tent map. The algorithm adopts a three-layer encryption architecture consisting of coordinate permutation, spatial permutation, and diffusion, enhancing both security and robustness through multi-stage processing.

By nonlinearly coupling dynamic cellular automaton rule switching with an improved logistic map, the proposed system achieves a 47.6% increase in the maximum Lyapunov exponent relative to the traditional tent map. The integration of dynamic rule switching and parameter sensitivity expands the theoretical key space to approximately $2^{135}$, providing a foundation for resistance against brute-force attacks. At the application level, the study makes two primary technical contributions. First, a dual-layer permutation mechanism is established by combining Arnold’s cat map with a maze traversal-based spatial scrambling algorithm: the former disrupts spatial structure through reversible coordinate transformation, while the latter performs a secondary global rearrangement of pixel positions via graph traversal. This strategy reduces the adjacent-pixel correlation coefficient in the encrypted image to below 0.0032 and increases the information entropy to 7.9993. Second, a dynamic rule diffusion strategy is introduced, wherein chaotic sequences govern the real-time selection of cellular automaton rules to perform nonlinear mixing of permuted pixel values. This approach not only diffuses minor pixel differences across the entire ciphertext image but also enhances robustness against noise and cropping attacks. Under 0.1-density salt-and-pepper noise and cropping of up to one-quarter of the image area, the decrypted images retain the main visual information.

Despite these advances, certain limitations remain. The current deterministic cellular automaton rule-switching mechanism could benefit from a stochastic stability analysis. Future work will incorporate modeling of rule transitions using Markov processes or stochastic differential equations and establish Lyapunov-based mean-square stability conditions, thereby providing probabilistic security guarantees and strengthening theoretical resistance to statistical cryptanalysis. To further improve the rigor and reproducibility of the evaluation framework, subsequent research will adopt standardized taxonomies and testing protocols for chaotic encryption. These will include systematic digital-chaos degradation analysis, extended security metrics, and cross-platform benchmarking, thereby enhancing the methodological completeness of the security assessment [77].