Modular Architecture for Artificial Intelligence Integration in Chaos- and Hyperchaos-Based Image Encryption Algorithms ^†

Abstract

This paper presents an architecture for integrating artificial intelligence (AI) functionalities into a chaos-based image encryption algorithm employing a Fibonacci matrix. The proposed approach aims to introduce dynamic behavior into the encryption process by generating the parameters of a chaotic or hyperchaotic system and the Fibonacci matrix based on numerical characteristics of the input image. The methodology incorporates two main innovations: a modular architecture for integrating AI models to automatically generate the parameters of the dynamical system and an AI-assisted procedure for determining the values of the Fibonacci Q-matrix. The algorithm is implemented in MATLAB and experimentally evaluated using AI models from four platforms: OpenAI, Gemini, Claude, and DeepSeek. The obtained results demonstrate values close to the theoretical reference values, with an average information entropy of 7.9966 and a mean absolute correlation coefficient of 0.001209. Robustness against different attacks is also investigated. The deviations of the overall mean values from their theoretical references are 0.000731 for NPCR and 0.002063 for UACI. Furthermore, the PSNR decreases by an average of 3.7747 dB when the salt-and-pepper noise density increases from 2% to 5%, and by 3.5577 dB when the data-cut level increases from 10% to 25%. The obtained results demonstrate the applicability of the proposed AI integration architecture for dynamically configuring chaos-based image encryption algorithms.

1. Introduction

From a simple post on social media, through routine workplace correspondence, to digital healthcare platforms, individuals continuously generate and share vast amounts of digital data, often without being fully aware of its scale. A considerable proportion of this information is produced in the form of digital images, which, with the increasing adoption of modern software tools for image generation and modification, are becoming progressively influenced by artificial intelligence (AI).

Widely used platforms for sharing digital content continuously seek to maintain high levels of protection against unauthorized access. Nevertheless, every platform remains exposed to persistent attacks aimed at collecting information that may subsequently be exploited in targeted cyberattacks. This situation necessitates increasingly stringent requirements for mechanisms designed to protect visual information. A fundamental framework for evaluating these requirements is the confidentiality, integrity, and availability triad, which represents a core model in cybersecurity [1]. Confidentiality requires that access to images be restricted exclusively to authorized users through the application of reliable cryptographic mechanisms [2] and secure transmission protocols [3]. Integrity ensures that image content has not been altered, replaced, or corrupted without authorization. For this purpose, digital signatures [4], hash functions [5], and other authentication and verification methods [6,7,8] are employed. Availability, in turn, ensures that protected data remain accessible to legitimate users when required through the use of resilient infrastructure [9] and secure communication channels [10].

The inability to guarantee a completely secure communication channel for the transmission of sensitive digital information has motivated extensive research into various encryption approaches. Image encryption algorithms can generally be classified as symmetric [11], asymmetric [12], chaos-based [13], fractal-based [14], and hybrid methods [15]. Some algorithms are based on classical cryptographic approaches, such as the one-time pad (OTP) [16,17], whereas others employ less conventional techniques, including chaotic synchronization schemes [18,19,20].

Considering the rapid development of AI technologies, a fundamental question arises regarding the role of AI in information-protection methods and algorithms, particularly in image encryption. AI has already been applied across numerous fields of science and engineering, including automotive manufacturing [21,22,23], industrial and power electronics [24,25,26], medicine [27,28,29,30,31,32], chemistry [33,34], and communication systems [35,36,37,38,39,40,41]. These applications are generally intended to automate human activities and reduce the need for direct human involvement in routine and time-consuming tasks. Therefore, the integration of AI into encryption algorithms based on chaotic systems represents a relevant and promising research area. This is particularly important given the ability of modern AI models to generate outputs by predicting the most probable sequences of tokens based on the supplied context and input constraints.

1.1. Related Works

The integration of artificial intelligence (AI) into chaos-based image encryption algorithms represents an emerging research area that has recently begun to develop at a rapid pace. Current studies are primarily aimed at overcoming the limitations of conventional approaches, improving algorithmic adaptability, and, most importantly, reducing or eliminating human intervention in the generation of encryption keys. An analysis of the recent literature concerning the relationship between AI and chaos-based encryption algorithms reveals several major research directions: the optimization of chaotic parameters and the development of hybrid approaches; the integration of deep learning and advanced neural network architectures; hardware implementations and applications in Internet of Things (IoT) and Internet of Medical Things (IoMT) environments; and the protection of AI systems and multidimensional data.

A considerable proportion of the existing studies focuses on the application of AI for the dynamic adjustment of chaotic-system parameters. In [42], AI was incorporated into a proposed modified Price algorithm that employs entropy as an optimality criterion, thereby providing a precise objective function for achieving an increased level of security. In a subsequent study [43], the same authors developed a hybrid approach combining chaotic systems, Fibonacci matrices, and a GPT-based model for the dynamic adaptation of the algorithm parameters. In [44], high performance was achieved, including an entropy value of 7.99 and a key space of (2^{511}), through a hybrid method integrating genetic algorithms, elliptic-curve cryptography, and chaotic maps. A similar optimization approach was applied in the Light-Crypt algorithm [45], in which AI was employed to optimize substitution boxes (S-boxes) combined with the Lorenz system. Despite the reported high efficiency, however, the successful completion of only 8 out of 12 NIST tests indicates that further validation of the algorithm’s cryptographic reliability is required.

Modern neural networks provide new possibilities for the generation of chaotic sequences and the semantic analysis of image content. In [46], a Chaos-Encoder Model was developed as a framework combining convolutional neural networks (CNNs) and transformers to generate image-dependent key streams. The semantic-guided encryption method presented in [47] employs Vision Transformers (ViTs) and chaotic systems, including the Lorenz system, to prioritize critical image regions and optimize the use of computational resources. For medical image encryption, the AT-ResNet-CM architecture was proposed in [48], combining an attention mechanism with logistic chaos to enhance the protection of diagnostically important regions. The use of recurrent neural networks has also demonstrated considerable potential. In [49], the LSTNet architecture was successfully employed to generate multidimensional chaotic signals. Nevertheless, a common limitation of these deep-learning-based approaches is the insufficient analysis of their computational complexity when they are scaled to large datasets.

The specific requirements of embedded devices and IoT systems necessitate the development of resource-efficient encryption solutions. For IoT applications, similar hybrid frameworks, namely EANMF and CNAIE, were presented in [50,51]. These frameworks combine Ascon, neural networks, and chaotic systems. High computational efficiency and parallel processing capabilities were also demonstrated and validated through the implementation of artificial neural networks (ANNs) and chaotic systems on field-programmable gate array (FPGA) hardware [52,53]. While EANMF primarily emphasizes FPGA-based hardware optimization and energy efficiency, CNAIE employs Q-learning to provide adaptive operation. In the context of the IoMT, a critical comparison between AI-based chaotic encryption, which is distinguished by its high processing speed, and blockchain technologies, which provide traceability, was presented in [54].

Several specialized studies have addressed the security of AI systems themselves, referred to as NSAI systems. The integration of chaos-based encryption algorithms for the protection of such systems represents a highly specialized cybersecurity approach [55]. Another related method [56] combines compressive sensing with a Rabinovich hyperchaotic system to ensure data confidentiality in AI environments. In response to the increasing risks associated with AI-generated threats, a video and image encryption method based on a four-dimensional chaotic system was proposed in [57], demonstrating a high level of robustness against noise.

1.2. Main Contributions

This paper proposes a modification of an image encryption algorithm based on chaos and the Fibonacci Q-matrix [58]. The modification introduces AI functionality, implemented through different AI models, into several modules of the encryption algorithm. A preliminary version of this work was published in [43]. The present study substantially extends the conference paper by including additional methodology, new experiments, an extended dataset, new comparative analyses, and additional results. In particular, the main contributions of the present article are as follows:

-

A modular architecture for implementing AI functionalities in an image encryption algorithm based on chaotic or hyperchaotic systems is proposed.

-

A modified version of an existing algorithm is implemented, combining a chaotic or hyperchaotic system and a Fibonacci matrix with AI capabilities with additional enhanced diffusion layer. The main advantage of the proposed approach is the automation of sensitive configuration stages, resulting in improved performance compared with the classical algorithm.

-

Through the presented MATLAB implementation and the performed security analyses, the dynamic association of the AI-generated values is demonstrated, leading to increased flexibility of the encryption procedure while preserving the mathematical structure required for the decryption process.

The remainder of the paper is organized as follows. Section 2 presents the main mathematical foundations. Section 3 describes the proposed architecture, together with the modification of the chaos-/hyperchaos-based image encryption algorithm incorporating integrated AI functionalities. Section 4 presents the main and additional experimental results, as well as an analysis of robustness against the principal attacks considered. Section 5 provides a discussion of the main aspects related to the integration of AI into image encryption algorithms. The conclusions are presented in Section 6.

2. Mathematical Foundations

2.1. Chaotic Models

In chaos-based image encryption methods, the selection of the chaotic system is of particular importance because of the strong sensitivity of such systems to variations in the initial conditions, the system parameter set, and the number of positive Lyapunov exponents. The presence of more than one positive Lyapunov exponent constitutes the principal distinction between chaotic and hyperchaotic systems.

To ensure the completeness of the present study, one chaotic system and one hyperchaotic system are considered. Hyperchaotic systems are generally characterized by more complex dynamical behavior and can therefore provide a higher level of information security. Subsequently, it is examined whether the implementation of AI is equally effective when applied to both chaotic and hyperchaotic systems.

2.1.1. Third Order Chaotic System

In 2024, Shukur et al. proposed a model of a third-order chaotic system with specific nonlinearity [59]:

$$\left\{\begin{array}{l}{\dot{\mathrm{x}}}_1={\mathrm{x}}_2\\ {\dot{\mathrm{x}}}_2={\mathrm{x}}_3\\ {\dot{\mathrm{x}}}_3={\mathrm{ax}}_1-\mathrm{b}{\mathrm{x}}_2-\mathrm{c}{\mathrm{x}}_3-\mathrm{d}{\mathrm{x}}_1\left|{\mathrm{x}}_1\right|\end{array}\right.$$

(1)

where the values of the system parameters are a = 1.8, b = 1.4, c = 0.43 and d = 0.1. The graphical interpretation of the chaotic attractor of the system is simulated under the following randomly chosen initial conditions $x_0={\left[0 0 -1 \right]}^T$, and presented in Figure 1.

Figure 1. Three-dimensional projection of the chaotic attractor of Shukur’s model.

2.1.2. Fourth-Order Hyperchaotic System

In 2026, a modification of a fourth-order hyperchaotic system was proposed. The system is described by the following equations:

$$\left\{\begin{array}{l}{\dot{\mathrm{x}}}_1=\mathrm{a}{\mathrm{x}}_1-{\mathrm{x}}_2{\mathrm{x}}_3\\ {\dot{\mathrm{x}}}_2={\mathrm{x}}_1{\mathrm{x}}_3-\mathrm{b}{\mathrm{x}}_2\\ {\dot{\mathrm{x}}}_3={\mathrm{x}}_1{\mathrm{x}}_2-\mathrm{c}{\mathrm{x}}_3+{\mathrm{x}}_1{\mathrm{x}}_4\\ {\dot{\mathrm{x}}}_4=-{\mathrm{x}}_1{\mathrm{x}}_3+\mathrm{d}\left|{\mathrm{x}}_2\right|\end{array}\right.$$

(2)

For the parameter values: $a=6, b=10, c=35, d=1$ and the initial-condition vector $x_0={\left[1 1 1 1 \right]}^T$, the system generates a hyperchaotic attractor with a complex topological structure [60]. For clearer visualization, the three-dimensional projections of the hyperchaotic attractor are presented together in Figure 2.

Figure 2. Three-dimensional projections of the hyperchaotic attractor.

Numerical analysis of the Lyapunov exponent spectrum shows that system (2) preserves hyperchaotic behavior $({\lambda }_1, {\lambda }_2 > 0)$ for $a \in [2.8, 6.9]$, $b \in [8.25, 24]$, $c \in [21.5, 150]$, and $d \in [-6, 4]$, while the narrower ranges $a \in [4, 6.8]$, $b \in [8.5, 24]$, $c \in [22, 80]$, and $d \in [-5, 4]$ are recommended for practical use. The basin of attraction of the attractor covers at least the hypercube $xᵢ\left(0\right) \in [-500, 500]$ (with the exception of the invariant equilibrium line x₁ = x₂ = x₃ = 0); therefore, the initial values are selected from the interval $xᵢ\left(0\right) \in [-100, 100]$ and are treated as fixed, publicly known values.

The Jacobian matrix of system (2) is

$$J\left(x\right)=\left[\begin{array}{cccc}a& -x_3& -x_2& 0\\ x_3& -b& x_1& 0\\ x_2{+x}_4& x_1& -c& x_1\\ -x_3& d·\mathit{sgn}\left(x_2\right)& -x_1& 0\end{array}\right]$$

(2a)

where the derivative of the non-smooth term $d\left|{\lambda }_2\right|$ is taken as $d·sgn\left({\lambda }_2\right)$. Although the Jacobian is not used in the encryption algorithm itself, which operates on the trajectory x(t), it provides the theoretical basis for employing system (2) as a generator of cryptographic sequences. Its trace, $J = a - b - c = -39 < 0$, is state-independent and proves that the system is dissipative, so that the trajectories remain confined to a bounded attractor and can be reliably normalised and quantised into pixel values. The equilibria form the line x₁ = x₂ = x₃ = 0, at which J has eigenvalues a, −b, −c and 0; hence all equilibria are saddle points and no stable equilibrium exists towards which the generator could converge and produce a trivial key stream, which also justifies excluding this line from the set of admissible initial conditions. Finally, the linearised variational equation $\delta ẋ = J\left(x\right(t\left)\right)\delta x$ is used to compute the Lyapunov spectrum $\lambda \approx (9.2, 1.6, 0, -50)$ and the Kaplan–Yorke dimension $D_{KY} \approx 3.22$, which confirm the hyperchaotic nature of the attractor and quantify the extreme sensitivity to initial conditions and parameters on which the key sensitivity and the security of the proposed image encryption scheme rely.

2.2. Fibonacci Q-Matrix

In mathematics, the Fibonacci sequence is a sequence in which each element is the sum of the two elements that precede it [61]. The sequence is closely related to the golden ratio and has been studied in various scientific fields for hundreds of years.

The Fibonacci Q-matrix is the matrix defined by

$$\mathrm{Q}=\left[\begin{array}{cc}{\mathrm{F}}_2& {\mathrm{F}}_1\\ {\mathrm{F}}_1& {\mathrm{F}}_0\end{array}\right]=\left[\begin{array}{cc}1& 1\\ 1& 0\end{array}\right],$$

(3)

where F_n is a Fibonacci number. The Fibonacci numbers are defined by the recurrence relation $F_n=F_{n-1}+F_{n-2}$ for n ≥ 2 with the initial conditions F₀ = 0 and F₁ = 1, which yields F₂ = 1 and hence Q = [1 1; 1 0]; the sequence is extended to negative indices by $F_{-n}={(-1)}^{(n+1)}{F}_n$. Then,

$${\mathrm{Q}}^{\mathrm{n}}=\left[\begin{array}{cc}{\mathrm{F}}_{\mathrm{n}+1}& {\mathrm{F}}_{\mathrm{n}}\\ {\mathrm{F}}_{\mathrm{n}}& {\mathrm{F}}_{\mathrm{n}-1}\end{array}\right],$$

(4)

The Q-matrices immediately give a number of important Fibonacci identities, including

$$\left|Q^n\right|={\left|Q\right|}^n,$$

(5)

which gives

$$F_{n-1}{F}_{n+1}-F_n^2={\left(-1\right)}^n,$$

(6)

$$Q^{n+1}{Q}^n=Q^{2n+1},$$

(7)

Proofs of Equations (6) and (7) are presented in Appendix A. Therefore

$${\mathrm{Q}}^{\mathrm{n}}=\left[\begin{array}{cc}{\mathrm{F}}_{\mathrm{n}+2}& {\mathrm{F}}_{\mathrm{n}+1}\\ {\mathrm{F}}_{\mathrm{n}+1}& {\mathrm{F}}_{\mathrm{n}}\end{array}\right]\left[\begin{array}{cc}{\mathrm{F}}_{\mathrm{n}+1}& {\mathrm{F}}_{\mathrm{n}}\\ {\mathrm{F}}_{\mathrm{n}}& {\mathrm{F}}_{\mathrm{n}-1}\end{array}\right]=\left[\begin{array}{cc}{\mathrm{F}}_{2\mathrm{n}+2}& {\mathrm{F}}_{2\mathrm{n}+1}\\ {\mathrm{F}}_{2\mathrm{n}+1}& {\mathrm{F}}_{2\mathrm{n}}\end{array}\right],$$

(8)

and

$$Q^m{Q}^{n-1}=Q^{m+n-1},$$

(9)

which gives [34]

$${\mathrm{Q}}^{\mathrm{n}}=\left[\begin{array}{cc}{\mathrm{F}}_{\mathrm{m}+1}& {\mathrm{F}}_{\mathrm{m}}\\ {\mathrm{F}}_{\mathrm{m}}& {\mathrm{F}}_{\mathrm{m}-1}\end{array}\right]\left[\begin{array}{cc}{\mathrm{F}}_{\mathrm{n}}& {\mathrm{F}}_{\mathrm{n}-1}\\ {\mathrm{F}}_{\mathrm{n}-1}& {\mathrm{F}}_{\mathrm{n}-2}\end{array}\right]=\left[\begin{array}{cc}{\mathrm{F}}_{\mathrm{m}+\mathrm{n}}& {\mathrm{F}}_{\mathrm{m}+\mathrm{n}-1}\\ {\mathrm{F}}_{\mathrm{m}+\mathrm{n}-1}& {\mathrm{F}}_{\mathrm{m}+\mathrm{n}-2}\end{array}\right]$$

(10)

Proofs of Equation (10) is presented in Appendix B.

The inverse matrix Q⁽⁻ⁿ⁾ has the following form:

$${\mathrm{Q}}^{-\mathrm{n}}={(-1)}^n\left[\begin{array}{cc}{\mathrm{F}}_{\mathrm{n}-1}& {-\mathrm{F}}_{\mathrm{n}}\\ -{\mathrm{F}}_{\mathrm{n}}& {\mathrm{F}}_{\mathrm{n}+1}\end{array}\right].$$

(11)

3. Modification of the Encryption Algorithm

3.1. Introducing a Modified Algorithm Based on Chaos and Fibonacci Q-Matrix

The algorithm is based on a signal from a hyperchaotic system and the Fibonacci Q-matrix. The basic algorithm, along with a detailed presentation of the method, is provided in [58].

Encryption is carried out in two main stages: confusion and diffusion. During the confusion process, the arrangement of pixels is altered, while in the diffusion process, their values are modified. This method utilizes a novel third-order chaotic and forth order hyperchaotic systems. At first, the system’s initial state is computed based on the original image. Then, through iterations of the chaotic or hyperchaotic system, a new vector (x1, x2, and x3) is generated. This vector is sorted, and the positions of the sorted values are used to confuse the original image.

Once the confusion stage is complete, the diffusion process is applied to obtain the encrypted image. In the current algorithm, diffusion is implemented using the Fibonacci Q-matrix. The scrambled image is divided into blocks of size 2 × 2, with each block being transformed using the Fibonacci Q-matrix. Since the final diffusion step is a linear transformation, an additional step was implemented to enhance the diffusion stage: nonlinear XOR diffusion using an independent chaotic keystream. To ensure a higher level of security, the confusion and diffusion stages are performed twice.

3.2. Modification of the Algorithm Through the Integration of AI Functionalities

Algorithms of this type provide a high level of security; however, they also exhibit certain limitations, primarily related to the generation of the encryption key. The incorporation of artificial intelligence is expected to improve the performance of the considered encryption scheme by increasing its flexibility and efficiency when processing color images.

The proposed modification involves the use of AI to determine the parameters and initial conditions of the chaotic system, as well as the Fibonacci matrix, based on selected properties of the image to be encrypted. Consequently, these stages of the encryption process acquire a dynamic character. In addition to the integration of AI, the algorithm is further modified through the use of either the third-order chaotic system or the fourth-order hyperchaotic system described and analyzed in the preceding section.

A block diagram of the modified algorithm is presented in Figure 3.

Figure 3. Block diagram of the modified algorithm using artificial intelligence and the chaotic/hyperchaotic system.

The images considered for encryption are color images of size (M × N). Each image can be represented as a vector-valued function of two spatial variables:

$$f(x,y)=\left[\begin{array}{c}{f}_R(x,y)\\ f_G(x,y)\\ f_B(x,y)\end{array}\right],$$

(12)

where x and y denote the spatial coordinates, while $f$ represents the color value at the corresponding image location. The functions $f_R, f_G, \mathrm{and} f_B$, specify the intensity values of the red, green, and blue color channels, respectively. After spatial discretization, the image is represented as a three-dimensional array defined by

$$I\in Z_{256}^{M\times N\times n_c},$$

(13)

where each pixel value in a given color channel is represented by an 8-bit integer belonging to the set $f\left(x,y\right)=\{\mathrm{0,1},\dots ,255\}$. The parameter $n_c$ denotes the number of image channels and usually takes the value 1- for grayscale images and 3 for color images. The individual color components are represented by $I_R\left(:,:,1\right),I_G\left(:,:,2\right) \mathrm{and} I_B\left(:,:,3\right).$ At the beginning of the image encryption process, the initial conditions and system parameters are determined and initialized. This stage includes validation of the input image, verification of the specified number of encryption iterations, and confirmation that a valid API key has been provided.

The image dimensions are first extracted. Owing to the use of the 2 × 2 Fibonacci Q-matrix, the number of rows and columns must be even. If M or N is odd, the image is zero-padded with one additional row and/or column, so that the adjusted dimensions are

$$\begin{array}{c}{M}^{\prime }=M+\mathit{mod}\left(M,2\right),\\ N^{\prime }=N+\mathit{mod}\left(N,2\right).\end{array}$$

(14)

Consequently, if

$$M^{\prime }\equiv 0 \left(mod 2\right) \mathrm{and} N^{\prime }\equiv 0(mod 2),$$

(15)

and the padded image is

$$I^{\prime }\equiv R_{M^{\prime },N^{\prime }}\left(I\right),$$

(16)

where $R$ denotes a zero-padding operator. The original dimensions M and N are stored together with the cipher image. After decryption, the padded row and/or column are discarded, so that the original image is recovered exactly and the scheme remains lossless; the padded pixels carry no information and are simply removed. When M and N are already even, no padding is applied.

The iterative encryption procedure begins by converting the image data in each color channel into matrices of type double. Encryption is subsequently performed independently for each color channel. Let $I_q$ denote the q-th color channel, such that

$$I_q=I\left(:,:,q\right) for q=1,2,3$$

(17)

To formally describe the encryption procedure, the operator $E$ is introduced. The encrypted (q)-th color channel is then represented as

$$C_q=E_{\theta }^{\left(r\right)}\left(I_q,S_q\right),$$

(18)

where $\theta =\left(a,b,c,d\right)$ denotes the parameter vector of the chaotic or hyperchaotic system, r is the number of encryption rounds, and $S_q$ is the key-stream matrix of size $M^{\prime }\times N^{\prime }$ associated with the (q)-th color channel. It is generated from the chaotic or hyperchaotic system, integrated from the secret initial condition $x_0$ with the parameter vector $\theta$; the first $N_t$ samples are discarded as a transient, and the following $M^{\prime }·N^{\prime }$ samples of the (q)-th state variable $x_{q\left(k\right)}$ are quantised to the range [0, 255] and rearranged row-wise into a matrix:

$$\begin{array}{c}{S}_q\left(i,j\right)=mod\left(\left[\left|x_q\left(k\right)\right|· {10}^{14}\right], 256\right),\hspace{1em} for \\ k = (i - 1)N^{\prime } + j,\hspace{1em}i = 1, \dots , M^{\prime },\hspace{1em}j = 1, \dots , N^{\prime }.\end{array}$$

(18a)

Thus, the three color channels are encrypted with three different components of the same trajectory.

The next step consists of generating the parameters of the chaotic or hyperchaotic system, together with the initial conditions of the state vector. The generated parameters and initial conditions are validated within the main part of the algorithm. The validation procedure addresses the following cases:

• No parameters are returned by the AI model. In this case, the request is resubmitted, with a maximum of three attempts. If the request remains unsuccessful after the third attempt, the absence of Internet connectivity is assumed and predefined default values are used.
• The generated parameter values lie outside the admissible ranges. Each parameter is verified against predefined constraints that ensure the preservation of the chaotic or hyperchaotic behavior of the system. Parameters acting as bifurcation parameters should preferably not vary over excessively wide intervals. Nevertheless, their variation is essential because it contributes directly to the key-sensitivity property of the encryption algorithm.
• Initial conditions of the state vector. Owing to the characteristic sensitivity of chaotic systems to initial conditions, these values are selected within predefined regions of attraction of the attractor in order to ensure the desired dynamical behavior.

At the beginning of each encryption round, the two-dimensional image matrix is transformed into a one-dimensional vector of type double. In the MATLAB implementation, column-major vectorization is applied as follows:

$$P=\left[\begin{array}{c}I(1,1)\\ I(2,1)\\ \begin{array}{c}⋮\\ I(M,1)\\ \begin{array}{c}I(1,2)\\ \begin{array}{c}⋮\\ I(M,N)\end{array}\end{array}\end{array}\end{array}\right] \in {\mathbb{R}}^{\mathit{MN}}$$

(19)

The next stage of the encryption procedure involves the generation of two arrays containing values obtained by numerically solving the chaotic system for the AI-generated parameters and initial conditions. The Dormand–Prince method is employed for this purpose. This numerical method integrates the system of ordinary differential equations $y^{\prime }=f\left(t,y\right),$ over the interval from $t_0={\displaystyle \frac{0.9865\times M\times N}{3}}$ to $tf =Q$. Consequently, an output matrix Y is obtained, containing a sufficient number of samples of each state variable to generate a sequence of length M × N For the third-order chaotic system, the numerical solution is represented as

$$Y=\left[\begin{array}{ccc}{x}_1\left(t_1\right)& x_2\left(t_1\right)& x_3\left(t_1\right)\\ x_1\left(t_2\right)& x_2\left(t_2\right)& x_3\left(t_2\right)\\ \begin{array}{c}⋮\\ x_1\left(t_Q\right)\end{array}& \begin{array}{c}⋮\\ x_2\left(t_Q\right)\end{array}& \begin{array}{c}⋮\\ x_3\left(t_Q\right)\end{array}\end{array}\right] \in {\mathbb{R}}^{\mathit{Qx}3},$$

(20)

where the sampling instants are defined as

$$t_Q=t_0+{\displaystyle \frac{q-1}{Q-1}}\left(t_f-t_0\right), for q=1,\dots , Q.$$

(21)

Because $3Q=3\lceil {\displaystyle \frac{3MN}{3}} \rceil \ge MN$, the condition required to construct a sequence of length $MN$ is satisfied. The matrix Y is subsequently transformed into a new array L with dimension M × N × 3 of type double, which contains the values generated from the state variables x₁, x₂ and x₃ of the chaotic system. Different realizations of these state variables can be obtained through the use of AI-generated system parameters and initial conditions. It should be noted, however, that the more complex fourth-order hyperchaotic system requires a longer numerical integration time and therefore results in a higher computational cost.

The array L is sorted in descending order, and the resulting permutation indices are stored in a new array S. The permutation vector corresponding to the r-th encryption round is then defined as

$$SS\left\{r\right\}=S^{\left(r\right)}.$$

(22)

A spatial permutation is subsequently performed, in which the image pixels are rearranged in vector form according to

$$R=P\left(S\right).$$

(23)

The resulting permuted vector is reshaped into a matrix $R$, from which the permuted image is reconstructed.

The next stage represents the third application of AI within the proposed algorithm, namely, the generation of a dynamic Fibonacci Q-matrix. In general, the Fibonacci transformation consists of partitioning R‘ into non-overlapping 2 × 2 blocks. Each block is subsequently transformed using the AI-generated Fibonacci (Q)-matrix. The image block is defined as

$$C_{u,v}=\left[\begin{array}{cc}{R}^{\prime }(2u-1, 2v-1)& R^{\prime }\left(2u-1, 2v\right)\\ R^{\prime }(2u, 2v-1)& R^{\prime }(2u,2v)\end{array}\right],$$

(24)

where $u=1,\dots ,{\displaystyle \frac{M}{2}}$ and $v=1,\dots ,{\displaystyle \frac{N}{2}}$.

The block-processing procedure is repeated for all ${\displaystyle \frac{M\times N}{4}}$ non-overlapping blocks. As a result, the encrypted matrix C is obtained.

At the final stage of the encryption process, the Fibonacci (Q)-matrix transformation is applied to each image block. Let the Fibonacci matrix be defined as $A = [a_1,a_2;a_3,a_4]$ and let the corresponding input block be $C_{u,v}=\left[p_1,p_2;p_3,p_4\right].$ The transformed block is then obtained as

$$F_{u,v}=C_{u,v}A.$$

(25)

If the current round is not the final encryption round, the resulting matrix is converted back into the vector P and the preceding steps are repeated. If the current round is the final one, the resulting matrix constitutes the encrypted output image.

A modular reduction is subsequently applied, whereby all resulting values are reduced modulo 256. For each 2 × 2 block, this operation is expressed as

$${\tilde{C}}_{u,v}=C_{u,v}A (mod 256).$$

(26)

Accordingly, the (r)-th encryption round can be represented as the following composition of transformations:

$$E_r=B_A\circ P_{S^{\left(r\right)}},$$

(27)

where $B_A$ denotes the blockwise Fibonacci transformation followed by modular reduction, and $P_{S^{\left(r\right)}}$ denotes the chaotic permutation defined by the permutation vector.

3.2.1. Enhanced Diffusion Layer

Algorithms whose final diffusion step relies exclusively on linear transformations (e.g., modular matrix multiplication), without an accompanying nonlinear operation (XOR with a chaotic keystream, S-box substitution, etc.), are vulnerable to statistical tests that are sensitive to local structure, such as template matching, DFT, serial, and approximate entropy tests, regardless of the number of encryption rounds. Owing to this identified weakness, an additional stage is introduced to improve the robustness of the algorithm against such statistical tests, namely, XOR-based diffusion using an independent chaotic keystream.

By linking the initial conditions of the same chaotic/hyperchaotic system to the sum of the image pixel values, the color-channel index, and the number of the encryption round, an independent chaotic keystream is generated. This keystream is then used for XOR-based diffusion applied to the intermediate result obtained after the permutation and Fibonacci transformation stages.

Accordingly, for the additional keystream, the initial conditions are modified according to the functional dependence in (28), based on the current image data and the encryption-round number, while also depending on the color channel:

$$x_{0,k}^{\left(r\right)}=F\left(x_{0,s}^{\left(r\right)},r\right),$$

(28)

where $x_{0,k}^{\left(r\right)}$ is the initial vector of the new keystream, and $x_{0,s}^{\left(r\right)}$ is the image-dependent scalar value corresponding to the r-th round.

Using the initial conditions obtained in this way, an independent chaotic keystream is generated in a manner similar to that described in the other part of the algorithm. The generated chaotic trajectories are converted into an 8-bit sequence using the floor and mod 256 functions. This sequence is denoted by $K_i^{\left(r\right)} for i=1,2,\dots ,MN$.

The encrypted image obtained up to this stage, after the previously described permutation and Fibonacci transformation stages, can be represented as

$$I_{base\_enc}^{\left(r\right)}=E_r\left(I^{(r-1)}\right),$$

(29)

This intermediate result is vectorized, after which a bitwise XOR operation is applied between each element of the intermediate encrypted vector and the corresponding element of the chaotic keystream:

$$Z_i^{\left(r\right)}=V_i^{\left(r\right)}⨁K_i^{\left(r\right)},$$

(30)

where $V_i^{\left(r\right)}$ denotes the vectorized intermediate result.

After the XOR operation, the resulting vector is reshaped back into an $M\times N$ matrix and forms the output of the current encryption round. If $X_{K^{\left(r\right)}}$ denotes the operator of XOR-based diffusion using an independent chaotic keystream, then, taking (27) into account, the extended operator for the r-th encryption round can be written as

$${\tilde{E}}_r=X_{K^{\left(r\right)}}\circ E_r.$$

(31)

For a total of RR encryption rounds, the encrypted image can be represented as a sequence of composed transformations:

$$I_{enc}={\tilde{E}}_R\circ {\tilde{E}}_{R-1}\circ \cdots \circ {\tilde{E}}_1\left(I\right)$$

(32)

3.2.2. Decryption Process

The decryption process generally proceeds in the reverse order, with the modified algorithm applying the following inverse operations: inverse XOR transformation, inverse Fibonacci transformation, and inverse permutation. When multiple encryption rounds are used, decryption starts from the final round.

If the encrypted image for a single round is represented by (31), and the final encrypted image by (32), then the inverse operator is given by

$${\tilde{E}}_r^{-1}=P_{S^{\left(r\right)}}^{-1}\circ B_A^{-1}\circ X_{K^{\left(r\right)}}.$$

(33)

where $S^{\left(r\right)}$ is the permutation vector and $K^{\left(r\right)}$ is the chaotic key sequence. These are stored during encryption in the structure $SS=\left\{S^{\left(r\right)}, K^{\left(r\right)}\right\}$ for each encryption round.

At the beginning of each decryption round, the current encrypted image $I^{\left(r\right)}$ is vectorized to obtain $Z^{\left(r\right)}=vec\left(I^{\left(r\right)}\right)$. Since XOR is a self-inverse operation, the intermediate vector prior to the XOR diffusion stage is recovered as

$$V^{\left(r\right)}=Z^{\left(r\right)}\oplus K^{\left(r\right)}, k=1,\dots ,MN.$$

(34)

The resulting vector is then reshaped back into an $M\times N$ matrix in order to perform the subsequent inverse operations:

$$I_{base\_enc}^{\left(r\right)}=reshape \left(V^{\left(r\right)},M,N\right).$$

(35)

The previously introduced inverse operations of the basic encryption core are then applied. The possibility of obtaining the inverse Fibonacci Q-matrix forms the basis of the subsequent decryption steps, beginning with the inverse block transformation, for which

$$C_{u,v}={\tilde{C}}_{u,v}{A}_{256}^{-1} (\mathrm{mod} 256).$$

(36)

After all blocks have been processed, they are restored to their corresponding spatial positions, thereby forming the matrix $D^{\left(r\right)}$ of size $N\times M$. Following the inverse block transformation, the matrix $D^{\left(r\right)}$ is vectorized to obtain the vector $W^{\left(r\right)}$. After modular reduction, this vector corresponds to the permuted vector generated during the encryption process:

$$R_k^{\left(r\right)}=W_k^{\left(r\right)} mod 256, \mathrm{for} \mathrm{k}=1, \dots ,\mathrm{MN}.$$

(37)

The recovery of the vector prior to permutation can be expressed as

$$P^{(r-1)}=R^{\left(r\right)}\left(S_{inv}^{\left(r\right)}\right),$$

(38)

where the inverse permutation is applied. The inverse permutation vector $S_{inv}^{\left(r\right)}$ is obtained by sorting the permutation vector S in ascending order and retaining the corresponding indices.

The recovered vector is converted back into an image using the $reshape$ and $mod$ functions. This operation is expressed as

$$I^{(r-1)}=mod\left[reshape \left(R^{\left(r\right)}\left(S_{inv}^{\left(r\right)}\right),M,N\right),256\right].$$

(39)

The resulting image corresponds to the image state immediately preceding the r-th encryption round. For a total of R encryption rounds, the complete decryption procedure can be represented as

$$I^{\left(0\right)}={\tilde{E}}_1^{-1}\circ {\tilde{E}}_2^{-1}\circ \dots \circ {\tilde{E}}_R^{-1} \left(I_{enc}\right).$$

(40)

After all decryption rounds have been completed, the recovered matrix associated with each color channel is converted into an 8-bit unsigned integer representation. The individual channels are subsequently combined to reconstruct the final decrypted color image.

Figure 4 presents the pseudocode of the modified algorithm, while Figure 5 shows the pseudocode of the “Encrypt” function.

Figure 4. Pseudocode of the modified algorithm.

Figure 5. Pseudocode of the encryption function.

3.3. Implementation and Integration of AI Functionality in the Modified Algorithm

As mentioned above, the AI functionality is integrated into two algorithmically sensitive modules: the generation of the chaotic-system parameters and the generation of the initial Fibonacci matrix. The use of AI is implemented through separate subroutines, one responsible for generating the chaotic-system parameters and another for generating the Fibonacci matrix. Four AI models hosted on different platforms are investigated: GPT-4, Gemini 3.1 Flash-Lite, Deep Seek V4 Flash, and Claude Haiku 4.5-20251001, provided by OpenAI, Google Gemini, Deep Seek, and Anthropic, respectively. Consequently, a total of eight subroutines are implemented: four for generating the system parameters and four for generating the Fibonacci matrix. The subroutines follow a common structure because the same communication approach, based on HTTP requests, is employed in all cases. The principal structural differences associated with the use of the individual models are described at the corresponding implementation stages. The general structure of the subroutines comprises several stages:

• Determination of Image Properties-In the current implementation, three statistical image properties are determined: the entropy $H$, the mean intensity ${ \mu }_I$, and the contrast ${\sigma }_I,$ defined by Equations (41)–(43), respectively. Other image descriptors, such as the image histogram, may also be employed. It is additionally possible to provide the complete image as input to the AI model. However, processing an entire high-resolution image may substantially increase the computational and communication overhead. Therefore, the use of a representative $64\times 64$ image fragment is recommended. This fragment introduces additional image-dependent information into the parameter-generation procedure and may thereby increase the effective key diversity of the proposed algorithm. The image entropy is calculated as

  $$H\left(I\right)=-\sum _{i=0}^{255}p\left(x_i\right)p\left(x_i\right)$$

  (41)

  where $p\left(x_i\right)$ is the probability with which the i-th intensity value $x_i$ in the image $I$.
  For an image with $n_c$ color channels, the mean intensity is expressed as

  $${ \mu }_I={\displaystyle \frac{1}{MN{n}_c}}\sum _{q=1}^{n_c}\sum _{i=1}^M\sum _{j=1}^{N}I(i,j,q)$$

  (42)
  The image contrast is estimated using the sample standard deviation:

  $${\sigma }_I=\sqrt[ ]{{\displaystyle \frac{1}{P-1}}\sum _{i=1}^P{(y_i-{ \mu }_I)}^2}$$

  (43)

  where $y$ denotes the vectorized image and $P= MN{n}_c$ is the total number of pixel-channel values.
• Definition of the Operational Prompts—When working with AI, the prompt represents the primary input interface to the model. In general, it is a text-based instruction submitted to the model in the format required by the corresponding platform. It is well established that prompt formulation has a substantial influence on the responses generated by different AI models. The principal prompt used to generate the parameters of the chaotic or hyperchaotic system is implemented in MATLAB as follows:
  prompt = sprintf([‘Generate optimized chaotic encryption parameters (a, b, c, d) for a Shukur system based on image entropy %.2f, mean intensity %.2f, and contrast %.2f. Output only four floating point numbers separated by spaces.’], entropy_value, mean_intensity, contrast);–for the chaotic system.
  This prompt is used for the chaotic system. When a hyperchaotic system, or a less widely known chaotic system, is employed, the complete system equations are included in the prompt:
  prompt = sprintf([‘Generate optimized hyper-chaotic encryption parameters (a, b, c, d) for the following 4D hyper-chaotic system dx1/dt = a*x1 − x2*x3\n dx2/dt = x1*x3 − b*x2\n dx3/dt = x1*x2 − c*x3 + x1*x4\n dx4/dt = −x1*x3 + d*abs(x2)\n\n with baseline parameters:\n a = 6, b = 10, c = 35, d = 1.\n\n based on image entropy %.2f, mean intensity %.2f, and contrast %.2f. Output only four floating point numbers separated by spaces.’], entropy_value, mean_intensity, contrast);
  The prompt used to generate the Fibonacci matrix is defined as follows:
  prompt = sprintf([‘Generate a 2 × 2 matrix based on Fibonacci numbers, suitable for use as a Q-matrix in dynamic system modeling. Base the values on image entropy %.2f, mean intensity %.2f, and contrast %.2f. Output only four floating point numbers (Fibonacci-based) in row-major order separated by spaces.’], entropy_value, mean_intensity, contrast);
  Each prompt must explicitly specify the required output format because the subsequent stages of the algorithm require numerical values. Otherwise, an additional parser function must be implemented to extract the required values from the natural-language response returned by the model.
  Regarding prompt compatibility, three of the four investigated models successfully process the general syntax presented above. However, the Deep Seek model requires substantial modifications owing to several specific characteristics observed during its integration:

  -

  Deep Seek V4 models provide a reasoning, or “thinking”, mode that is enabled by default. When this mode is active, generation parameters such as temperature may not affect the output and may be silently ignored.

  -

  The combined use of structured JSON output and an active thinking mode may result in an empty response.

  -

  When reference parameter values are included in the prompt, as required for the considered hyperchaotic system, the model may reproduce these values instead of generating new ones. This behavior corresponds to the well-known “anchoring” effect in prompt engineering.

  To address these issues, the thinking mode is disabled, and a retry mechanism is introduced to compensate for the observed instability in the system-prompt processing. Furthermore, the prompt intended for the DeepSeek model is modified as follows:
  prompt = sprintf(['Image statistics: entropy = %.4f, mean intensity = %.4f, contrast = %.4f. Generate FOUR NEW chaotic system parameters a, b, c, d for a Shukur-type system, computed specifically from these statistics. Different images MUST give different values–never reuse example or default numbers. Respond with ONLY a JSON object, no extra text, no markdown, in this exact shape: {"a": <number>, "b": <number>, "c": <number>, "d": <number>}'], entropy_value, mean_intensity, contrast);
• The complete request submitted to the AI model is organized as a JSON structure containing the required parameters, instructions, and configuration options. The request construction begins with the definition of a system message that assigns a specific role to the model. This message is formulated as a system prompt, for example, ‘You are an AI that provides optimized chaotic encryption parameters.’ As discussed in the preceding subsection, a modified system prompt and request configuration are employed for the Deep Seek model.
  The model type, maximum number of output tokens, and temperature are subsequently specified. In the current implementation, the selected models are ‘gpt-4’, ‘gemini-3.1-flash-lite’, ‘Deep Seek-v4-flash’, ‘claude-haiku-4-5-20251001’, with a maximum number of tokens not exceeding 50, which is sufficient for the intended purposes. These two parameters mainly affect the cost, response time, and operability. Temperature is another parameter that determines the randomness of the generated response. The higher its value, the more random the response will be for the same input data. The main difference in this case arises from the use of the Gemini and Claude APIs. The Gemini API and Claude API differ structurally from the OpenAI API, whereas the Deep Seek API is OpenAI-based. Table 1 summarizes the main implementation differences.
  Table 1. Summary comparison of the functions used.

  	OpenAI	Gemini	Deep Seek	Claude
  Model	gpt-4	gemini-3.1-flash-lite	Deep Seek-v4-flash	claude-haiku-4-5-20251001
  Endpoint	api.openai.com/v1/chat/completions	generativelanguage.googleapis.com/…/generateContent	api.Deep Seek.com/chat/completions	api.anthropic.com/v1/messages
  Authentication	1 header: Authorization: Bearer	1 header: x-goog-api-key	1 header: Authorization: Bearer	2 header-a: x-api-key + anthropic-version
  System prompt	Inside messages, role:‘system’	Separate systemInstruction.parts field—an array of objects	Inside messages, role:‘system’	Separate request.system field—a plain string
  JSON construction of messages	struct(‘role’,{…},’content’,{…}) → requires strrep	cell array {struct(…)} → clean JSON	cell array {msg_system, msg_user} → clean JSON	cell array {userMsg} → clean JSON
  max_tokens	50 (optional)	50 (optional)	50 (optional)	50 (mandatory)
  temperature	0.7, range [0, 2]	0.7, range [0, 2]	0.7, range [0, 2]	0.4, range [0, 1]
  Enforced JSON format	None	None	response_format: json_object	None
  Thinking/reasoning mode	—	—	thinking:disabled	—

• Formatting and Sending the Final Request—Before the request is sent, the JSON formatting is checked, corrected if necessary, and properly closed. This is required because of the specific manner in which MATLAB serializes an array of structures, and the resulting JSON sometimes does not conform to the expected syntax. The HTTP request options are defined using the weboptions function, including the API key, Content-Type, Timeout, and RequestMethod. The final request is sent to OpenAI using the webwrite function.
  For the other three models used, this stage is implemented in a similar, although not identical, manner. For example, when the Gemini API is used, the contents field is defined directly as a cell array, and therefore jsonencode generates a valid JSON structure without requiring additional correction. When the DeepSeek models are used, owing to the documented probability of receiving a response with empty content, the request is sent within a loop with up to three consecutive attempts. The principal difference in the Claude implementation concerns the system prompt, which is passed through a separate field (request.system) rather than as part of messages.
• Extraction of the AI Response—Despite the formatting specified in the main prompt, the response returned by the AI model is in text form, regardless of the output format requested in the prompt. It is converted into a numerical array by extracting all recognized floating-point numbers using the sscanf function. The validity of the obtained data is then verified arameter validation is performed by calculating the Lyapunov exponents. For the chaotic system, at least one positive Lyapunov exponent is required, whereas for the hyperchaotic system at least two positive Lyapunov exponents must be obtained. With respect to the Fibonacci matrix, the validation procedure verifies whether the generated 2 × 2 matrix satisfies the Fibonacci-matrix structure by checking the symmetric positions $\left(A\right(1,2)==A(2,1\left)\right)$ and the Fibonacci recurrence relation between its elements $\left(A\right(1,1) == A(1,2)+A(2,2\left)\right)$. The matrix is then tested for invertibility using modular arithmetic modulo 256, according to the condition $\left(gcd\right(round\left(d\right), 256) == 1)$. If the returned values do not represent valid parameters, predefined default values are selected. The same procedure is applied when the request cannot be completed, i.e., when internet access is unavailable. Unlike the parameters of the chaotic system, the default values of the Fibonacci matrix may also be functionally related to the numerical values of the image properties.
  At this stage, the main differences among the implementations are considerably smaller. They include checking for a missing field in the DeepSeek, Gemini, and Claude responses; using a deeper access path to retrieve the response text in the Gemini implementation; and extracting the numerical values through jsondecode and directly through a regular expression (regexp) in the DeepSeek and Claude implementations.

4. Results and Analysis

To test the modified algorithm, various standard color images from freely accessible databases w ere used. To evaluate the quality and level of image encryption, several widely used statistical and numerical analyses were employed, namely: Histograms, Correlation functions, Information entropy, NPCR, and UACI.

4.1. Main Results

The main test image selected for the experiments is “Peppers”. The original, encrypted, and decrypted images obtained using the four AI models and the chaotic system, together with their histograms and correlations, are presented in Table 2. The corresponding results obtained using the hyperchaotic system are presented in Table 3.

Table 2. Results obtained using chaotic system.

	Image			Histogram		Correlation
AI Model	Original	Encrypted	Decrypted	Original	Encrypted	Original	Encrypted
OpenAI
Gemini
Deep Seek
Claude

Table 3. Results obtained using hyperchaotic system.

	Image			Histogram		Correlation
AI Model	Original	Encrypted	Decrypted	Original	Encrypted	Original	Encrypted
OpenAI
Gemini
Deep Seek
Claude

The histogram of the encrypted image is stable, smooth, and evenly distributed, which demonstrates a high level of image encryption. This indicates that the resulting encrypted image does not provide any statistical information about the corresponding input image. Regarding the analysis of the correlation model, the degree of correlation between the original and encrypted images is extremely low, further confirming the high level of encryption achieved.

Table 4 presents the numerical results for information entropy, NPCR, and UACI coefficients.

Table 4. Numerical results.

		Entropy		Correlation		NPCR	UACI	${\mathit{\chi }}^2$
	AI Model	Original	Encrypted	Original	Encrypted
Chaos	OpenAI	7.3472	7.9993	0.9797	0.0016	99.6120	33.5105	247.05
	Gemini	7.3472	7.9993	0.9797	−0.0003	99.6070	33.4473	256.79
	Deep Seek	7.3472	7.9993	0.9797	−0.0005	99.5996	33.4593	253.96
	Claude	7.3472	7.9993	0.9797	0.0012	99.6129	33.4204	269.43
Hyperchaos	OpenAI	7.3472	7.9993	0.9797	−0.0002	99.6138	33.4488	241.47
	Gemini	7.3472	7.9992	0.9797	0.0020	99.6292	33.5118	273.24
	Deep Seek	7.3472	7.9993	0.9797	0.0005	99.6174	33.4911	272.00
	Claude	7.3472	7.9992	0.9797	0.0004	99.6059	33.4601	279.34

The presented numerical results indicate that the values of information entropy and NPCR are close to the theoretical maximum, while the correlation coefficient is significantly lower than that of the original image.

Based on the presented data, it can be concluded that the modifications introduced into the algorithm increase the information entropy and NPCR coefficients and significantly improve the correlation coefficient. The integration of AI models successfully fulfills the main task, namely, the generation of optimal coefficients for both the chaotic and hyperchaotic systems. With respect to the metrics used to evaluate the degree of image encryption, all AI models contribute values indicating a high level of protection.

4.2. Additional Results

In addition, the modified algorithm based on chaos/hyperchaos, AI models, and the Fibonacci Q-matrix has been tested with four additional standard test images. The obtained results are presented in Table 5.

Table 5. Numerical results for the additional images.

Entropy of the Original Image			7.6207	7.3515	7.3369	3.6077
Correlation of the Original Image			0.7326	0.9601	0.9359	0.9018
Chaos	OpenAI	Entropy of the EI	7.9986	7.9994	7.9999	7.9892
		Correlation of the EI	−0.0011	−0.0015	−0.0002	0.0002
	Gemini	Entropy of the EI	7.9985	7.9994	7.9999	7.9882
		Correlation of the EI	0.0008	−0.0008	0.0005	0.0004
	Deep seek	Entropy of the EI	7.9986	7.9994	7.9999	7.9884
		Correlation of the EI	−0.0011	0.0015	0.0009	−0.0013
	Claude	Entropy of the EI	7.9985	7.9993	7.9999	7.9887
		Correlation of the EI	0.0014	−0.0010	−0.0007	0.0066
Hyperchaos	OpenAI	Entropy of the EI	7.9984	7.9994	7.9998	7.9882
		Correlation of the EI	0.0019	0.0012	0.0003	−0.0001
	Gemini	Entropy of the EI	7.9985	7.9994	7.9998	7.9888
		Correlation of the EI	0.0002	−0.0013	−0.0003	0.0029
	Deep seek	Entropy of the EI	7.9985	7.9994	7.9999	7.9877
		Correlation of the EI	−0.0007	−0.0004	−0.0010	0.0044
	Claude	Entropy of the EI	7.9984	7.9994	7.9998	7.9890
		Correlation of the EI	−0.0005	0.0007	0.0002	0.0026

The results obtained for the additional set of test images confirm the conclusion presented in the previous subsection. The information entropy values are close to their theoretical maximum, while the correlation coefficients are close to zero, thereby demonstrating the effectiveness of the algorithm incorporating AI functionalities.

The obtained results clearly indicate that, for natural images, the choice of AI model and the type of chaotic system produce only minor variations in the evaluated metrics, with an average information entropy of 7.99925. With respect to correlation, the lowest mean absolute value, equal to 0.000467, is obtained for the combination of the Claude model and the hyperchaotic system. A distinct case is observed for the fourth image, for which the selection of the system type and AI model leads to more pronounced differences in the obtained results. However, the results do not indicate a consistent advantage of either the chaotic or the hyperchaotic system for this image, since the observed differences depend on both the selected AI model and the evaluated metric.

With respect to these metrics, for standard images, the choice of AI model does not have a substantial influence on the obtained results. At the same time, this demonstrates the stability of the proposed method with respect to the particular AI model employed. In other words, all investigated AI models generate suitable parameter values.

4.2.1. Differential Attack

One of the characteristic properties of encryption algorithms that are resistant to differential attacks is their exceptional sensitivity to even slight changes in the encoded image. The ability of the encryption algorithm to withstand differential attacks can be evaluated by analyzing the algorithm’s performance using the Number of Pixels Change Rate (NPCR) and Unified Average Changing Intensity (UACI) tests. Table 6 presents the values of the NPCR and UACI coefficients for the set of test images.

Table 6. Differential attack–numerical results.

			Baboon	Lighthouse	Flamingos	MRI
Chaos	OpenAI	NPCR	99.6141	99.6099	99.6103	99.5972
		UACI	33.4678	33.4728	33.4781	33.3696
		${\chi }^2$	237.12	268.66	247.69	244.36
	Gemini	NPCR	99.5896	99.6015	99.6081	99.6277
		UACI	33.5226	33.4614	33.4689	33.5055
		${\chi }^2$	252.64	241.49	260.58	266.73
	Deep Seek	NPCR	99.5910	99.6149	99.6070	99.5992
		UACI	33.4711	33.4646	33.4673	33.4415
		${\chi }^2$	237.54	244.27	251.13	262.48
	Claude	NPCR	99.6056	99.6131	99.6020	99.5972
		UACI	33.4518	33.4581	33.4545	33.3792
		${\chi }^2$	250.73	279.07	246.90	253.83
Hyperchaos	OpenAI	NPCR	99.6231	99.6047	99.6053	99.6175
		UACI	33.4313	33.4752	33.4668	33.4232
		${\chi }^2$	259.49	259.83	265.79	242.00
	Gemini	NPCR	99.6031	99.6106	99.6046	99.5972
		UACI	33.4909	33.4779	33.4712	33.5357
		${\chi }^2$	253.53	242.28	265.56	254.23
	Deep Seek	NPCR	99.6271	99.6029	99.6099	99.6094
		UACI	33.4383	33.4608	33.4745	33.6075
		${\chi }^2$	238.14	256.65	259.39	268.25
	Claude	NPCR	99.6017	99.6108	99.6049	99.6562
		UACI	33.4386	33.5308	33.4539	33.3866
		${\chi }^2$	270.22	246.34	263.09	251.00

The achieved high level of resistance to differential attacks is confirmed by the NPCR and UACI values, which are generally close to their theoretical reference values.

Practically all obtained NPCR values are concentrated around the theoretical reference value of 99.6094%. For example, when the chaotic system is combined with the OpenAI model, the deviation of the average NPCR value is only 0.001525. Among the hyperchaotic configurations, the combination with the DeepSeek model provides the closest average NPCR value to the theoretical reference, with a deviation of 0.002925 and an average NPCR of 99.6123%.

A similarly strong concentration around the theoretical reference value is observed for the UACI metric. The average UACI value is 33.4584% for the chaotic system and 33.4727% for the hyperchaotic system, compared with the theoretical reference value of approximately 33.4635%. Thus, both system configurations produce values close to the expected theoretical level. Additionally, the ${\chi }^2$ values are presented as a numerical measure of the statistical uniformity of the histograms of the investigated encrypted images. The values obtained for all investigated AI models remain below the commonly used critical value at a significance level of 0.05, with corresponding average values of 252.83 for the chaotic-system configuration and 255.99 for the hyperchaotic-system configuration.

4.2.2. Brute Force Attacks

The key space refers to the full range of potential key combinations that an encryption algorithm can employ. A sufficiently large key space—typically greater than $2^{100}$—is essential to prevent brute-force attacks.

For the algorithm under consideration, the key space depends on the parameters a, b, c, d of the chaotic/hyperchaotic system, in combination with the values of the Q matrix, whereas the initial conditions x_i(0) are fixed and not part of the secret key, as is common practice in many chaos-based encryption schemes. Rather than assuming a nominal 10¹⁶ distinguishable values per parameter, the estimate is restricted to the admissible intervals established in Section 2.1.2, which guarantee the hyperchaotic regime: a ∈ [4, 6.8], b ∈ [8.5, 24], c ∈ [22, 80], and d ∈ [−5, 4]. With a computational precision of 10⁻¹⁴ per parameter (consistent with IEEE 754 double-precision representation in these ranges), the number of distinguishable values is 2.8·10¹⁴, 1.55·10¹⁵, 5.8·10¹⁵, and 9·10¹⁴, respectively, and the resulting key space is K = (2.8 · 15.5 · 58 · 9) · 10⁵⁶ ≈ 2.27·10⁶⁰ ≈ 2²⁰⁰. The four elements of the Fibonacci matrix cannot be treated as fully independent key parameters, since they are determined by n. However, as a consequence of the matrix-generation procedure, n also becomes a secret parameter within the range [$0;N_{max}$]. In this case, an additional factor of [$1.97\times {10}^5$] can be included in the key space when the Pisano period is taken into account, resulting in an overall value of approximately [$x_0\times 2^{218}$].

Assuming that only the system parameters and the initial state $x_0$ are used as the shared secret key—which is common practice in chaos-based encryption algorithms—the resulting key space is at minimum equal to $x_0\times 2^{200}$. This value significantly exceeds the threshold required to resist brute force attacks, thereby ensuring a high degree of security.

4.2.3. Key Sensitivity

Sensitivity to secret keys is one of the important metrics used to characterize the reliability of an encryption algorithm. The key-sensitivity analysis was performed using the main test image, Peppers. First, the image was encrypted using a given AI-generated key. Subsequently, a very small change was introduced into one of the parameters, for example, a one-bit modification, and the decryption process was then performed. The decrypted image is expected to differ drastically from the original image.

The encryption algorithm was executed using the parameter values a = 1.80000000000000004441, b = 1.39999999999999991118, c = 0.42999999999999999334 and d = 0.10000000000000000555. Subsequently, parameter $a$ was modified by one bit, resulting in a new value of 1.79999999999999982236. Thus, the difference between the original and modified values was 2.220 × 10⁻¹⁶. Figure 6 presents the original image, the encrypted images obtained before and after modification of the parameter value, as well as the images decrypted using the correct and incorrect keys, respectively, for the implementation of the algorithm based on the chaotic system and the OpenAI model. The image shown in Figure 6f is a purely visual representation of the absolute difference between the two encrypted images shown in Figure 6b,c. If the algorithm exhibits high key sensitivity, this difference should resemble purely random noise, distributed uniformly throughout the image, without any visible contours, shapes, or traces of the original image.

Figure 6. Encrypted and decrypted images. (a) original. (b) encrypted (original key). (c) encrypted (key with 1 bit difference). (d) decrypted (original key). (e) decrypted (wrong key, 1 bit difference). (f) Abs. Diff. between two encrypted images.

As can be seen, the algorithm exhibits very high key sensitivity. In addition to the graphical results obtained for the two encrypted images, the corresponding NPCR and UACI values are 99.6089% and 33.5239%, respectively, both of which are close to their theoretical ideal values. When decryption is performed using an incorrect key, the comparison with the original image yields MSE = 10,109.1543 and PSNR = 8.0837 dB. Both values further confirm the high key sensitivity of the algorithm. The same test was also performed for the variant employing the hyperchaotic system, again by changing one bit of parameter $a$, with a difference of 8.882 × 10⁻¹⁶. between the original and modified values. In this case, the NPCR and UACI values are 99.6016% and 33.4336%, respectively. During decryption, the mean squared error is MSE = 10,100.2949, with PSNR = 8.0875 dB, which again indicates and confirms the high key sensitivity of the proposed algorithm.

4.2.4. Resistance to Noise and Data Loss

To assess the algorithm’s resistance to noise attacks, “Salt and Pepper” noise with varying density is added to the encrypted image. Subsequently, the affected images must be successfully decrypted. Additionally, it is necessary to evaluate the algorithm’s ability to decrypt an encrypted image that has missing segments of varying sizes. For quantitatively determining the quality of encryption algorithms when decrypting a corrupted image, the PSNR (Peak Signal-to-Noise Ratio) metric is used.

Table 7 and Table 8 present the results obtained for the main test image under noise and data-loss attacks.

Table 7. Results from “Salt and pepper” noise analysis.

	AI Model	“Salt and Pepper” Noise	Original	Encrypted	Decrypted	PSNR [dB]
Chaos	OpenAI	2%				19.2320
		5%				15.4435
	Gemini	2%				19.1231
		5%				15.4089
	Deep Seek	2%				19.3416
		5%				15.5921
	Claude	2%				19.3109
		5%				15.4871
Hyperchaos	OpenAI	2%				19.1514
		5%				15.4414
	Gemini	2%				19.2268
		5%				15.3520
	Deep Seek	2%				19.2307
		5%				15.4122
	Claude	2%				19.1271
		5%				15.4218

Table 8. Results from Data Cut Attack analysis.

	AI Model	Data Cut Attack	Original	Cropped Encrypted Image	Decrypted	PSNR [dB]
Chaos	OpenAI	10%				15.1300
		25%				11.5150
	Gemini	10%				15.5278
		25%				12.1025
	Deep Seek	10%				15.5374
		25%				12.2139
	Claude	10%				15.6252
		25%				12.2836
Hyperchaos	OpenAI	10%				15.3120
		25%				11.7761
	Gemini	10%				15.2973
		25%				11.7864
	Deep Seek	10%				15.2963
		25%				11.8912
	Claude	10%				15.3251
		25%				11.8289

Table 9 presents the PSNR results obtained under salt-and-pepper noise with densities of 0.02 and 0.05, as well as under data-cut attacks with data losses of 10% and 25%, for the additional set of test images, complementing the results obtained for the main test image presented in the preceding tables.

Table 9. PSNR for “Salt and Pepper” noise and Data cut attack.

			Baboon	Lighthouse	Flamingos	MRI
Chaos	OpenAI	S&P 0.02	19.9786	18.4016	19.8142	16.6953
		S&P 0.05	16.2970	14.6738	16.0537	12.8329
		Data cut–10%	15.9876	14.4221	15.8909	12.6661
		Data cut–25%	12.4933	10.6960	12.0295	9.1478
	Gemini	S&P 0.02	19.9311	18.4436	19.8150	16.6890
		S&P 0.05	16.2429	14.6314	16.0284	12.7521
		Data cut–10%	16.2988	14.6462	15.9917	12.9681
		Data cut–25%	12.8513	11.1482	12.5434	9.6419
	Deep Seek	S&P 0.02	20.1484	18.7151	19.8448	16.6304
		S&P 0.05	16.4119	14.8790	16.0994	13.0968
		Data cut–10%	17.2346	14.8355	15.9616	14.5948
		Data cut–25%	13.5967	11.4501	12.4106	10.7458
	Claude	S&P 0.02	20.2255	18.7214	19.8059	16.3353
		S&P 0.05	16.4376	14.9350	16.0494	12.6448
		Data cut–10%	17.2711	14.9426	15.9326	12.3749
		Data cut–25%	13.6018	11.6908	12.3489	8.7912
Hyperchaos	OpenAI	S&P 0.02	19.9813	18.4029	19.8147	16.6796
		S&P 0.05	16.1739	14.6412	16.0236	12.8112
		Data cut–10%	16.1544	14.5573	15.9417	12.7254
		Data cut–25%	12.6768	10.9936	12.3696	9.2682
	Gemini	S&P 0.02	19.9953	18.4095	19.8059	16.4992
		S&P 0.05	16.2135	14.6576	16.0243	12.6328
		Data cut–10%	16.1728	14.5544	15.9462	12.6745
		Data cut–25%	12.6345	10.9689	12.3657	9.2741
	Deep Seek	S&P 0.02	19.9664	18.4068	19.8587	16.5232
		S&P 0.05	16.2468	14.6519	16.0573	12.6213
		Data cut–10%	15.9953	14.8095	16.0623	12.8148
		Data cut–25%	12.5735	11.2939	12.3781	9.3033
	Claude	S&P 0.02	20.1680	18.4523	20.3671	16.4094
		S&P 0.05	16.2670	14.6786	16.6076	12.7570
		Data cut–10%	19.0883	14.5623	18.5245	12.7424
		Data cut–25%	14.6611	10.9600	14.5612	9.2223

For a salt-and-pepper noise attack with a density of 2%, the average PSNR values calculated over the complete set of test images and AI models are 18.8601 dB for the chaotic system and 18.8238 dB for the hyperchaotic system. When the noise density increases to 5%, the corresponding average values decrease, as expected, to 15.0999 dB and 15.0347 dB, respectively. Thus, the average reductions are 3.7603 dB for the chaotic system and 3.7892 dB for the hyperchaotic system, with an overall average reduction of approximately 3.7747 dB.

A similar tendency is observed for the data-cut attack. When 10% of the encrypted image data are removed, the average PSNR values are 15.1920 dB for the chaotic system and 15.2278 dB for the hyperchaotic system. When the data loss is increased to 25%, the corresponding average PSNR values decrease to 11.6651 dB and 11.6394 dB, respectively. This corresponds to reductions of 3.5269 dB and 3.5885 dB, with an overall average reduction of approximately 3.5577 dB.

The results indicate that the differences between the chaotic and hyperchaotic configurations are relatively small when averaged over the complete set of test images. For salt-and-pepper noise, the chaotic system provides slightly higher average PSNR values at both investigated noise densities. In contrast, for a 10% data-cut attack, the hyperchaotic system yields a slightly higher average PSNR, whereas at 25% data loss the chaotic system provides a marginally higher value. These differences are small and do not indicate a consistent superiority of either dynamical-system configuration with respect to robustness against the investigated attacks. Additionally, an experiment involving 30 independent non-deterministic realizations of the salt-and-pepper noise and data-cut attacks was conducted. For the salt-and-pepper noise attack, the obtained results were PSNR = 19.1943 ± 0.0406 dB at a noise density of 0.02 and PSNR = 15.4065 ± 0.0263 dB at a noise density of 0.05. For the data-cut attack, the corresponding values were PSNR = 15.2849 ± 0.1819 dB at 10% data loss and PSNR = 11.5942 ± 0.3008 dB at 25% data loss.

The influence of the selected AI model is also relatively limited for the salt-and-pepper noise attack, although more pronounced differences are observed for some individual images under data-cut attacks. Considering the complete set of test images and both dynamical-system configurations, the Claude model provides the highest average PSNR values for both investigated salt-and-pepper noise densities and both data-cut levels. Nevertheless, the results obtained with all four AI models remain comparable and exhibit the same general tendency: increasing the intensity of either noise or data loss leads to a reduction in PSNR and, consequently, to a deterioration in the quality of the recovered image.

4.2.5. Run-Time Performance Analysis

When estimating the computational complexity of the algorithm using O(…) notation, it becomes evident that the overall complexity primarily depends on the size of the input image. In other words, the algorithm has a complexity of O(NxM). However, a more practical insight into the computational cost and execution time can be obtained through the use of MATLAB’s Run-Time Profiler, as the algorithm is implemented and tested within the MATLAB environment.

For the evaluation of the average execution time, the main program records the time required to send the request to the AI model and receive its response, as well as the average time required for encryption and decryption. The results obtained for a 256 × 256 image are summarized in Table 10. Figure 7 presents a flame graph for a single encryption of the main test image, together with a table listing the functions with the highest execution times.

Table 10. MATLAB Run-time performance results.

	AI Model	Using AI	Encrypt	Decrypt	Total Time
Chaos	Open AI	1.991 s	1.081 s	0.048 s	10.021 s
	Gemini	3.823 s	1.253 s	0.052 s	13.197 s
	Deep Seek	1.212 s	1.194 s	0.053 s	10.349 s
	Claude	1.337 s	1.232 s	0.049 s	9.971 s
Hyperchaos	Open AI	1.320 s	1.390 s	0.051 s	9.983 s
	Gemini	3.339 s	1.403 s	0.050 s	11.899 s
	Deep Seek	1.306 s	1.405 s	0.051 s	10.049 s
	Claude	1.253 s	1.407 s	0.051 s	10.318 s

Figure 7. Flame graph and profile summary of execution of single time encryption process.

An important clarification before analyzing the obtained results is that the total execution time reported in Table 10 and Figure 7 also includes the time required for operations such as file opening, saving the encrypted image, visualization, calculation of image characteristics, data conversion, and other program-related operations. Therefore, the total execution time reported in Table 10 does not correspond to the sum of the execution times presented in the preceding columns.

The obtained results clearly indicate that the method used to send the request to the AI model is not a determining factor. Instead, the execution time primarily depends on network bandwidth, latency, endpoint load, and any possible rate limiting applied at the endpoint. Regarding the encryption process, most of the required execution time is consumed by the subroutine responsible for solving the system of differential equations describing the chaotic system. For this reason, the choice of AI model plays an important role, since the generated parameter values may lead the system to a regime in which the specified integration tolerances cannot be achieved without reducing the integration step size, resulting in a substantial increase in computational time. Nevertheless, the time required to obtain the parameters from the AI model should not be disregarded, since some models hosted on different platforms may be heavily loaded, which may also significantly increase request-processing time. In the current implementation, models characterized by fast request processing without substantial waiting times were selected.

The reported values clearly show that the shortest parameter-generation time is achieved by the DeepSeek model for the chaotic system (1.212 s), whereas Claude provides the shortest parameter-generation time for the hyperchaotic system (1.253 s). With respect to encryption, the average execution time for the hyperchaotic system (1.4013 s) is 1.18 times higher than that obtained using the chaotic system (1.1900 s), which is attributed to the higher dimensionality and greater complexity of the hyperchaotic system.

In contrast to encryption, the decryption time remains practically unchanged. This is because the dynamical system is not integrated again during decryption; instead, the previously stored permutation vectors are used.

Among the investigated configurations, Chaos–Claude achieves the shortest overall execution time of 9.971 s, whereas among the hyperchaotic configurations, the combination with the OpenAI model achieves an execution time of 9.983 s. It can therefore be concluded that the computational differences between the chaotic and hyperchaotic implementations are primarily associated with the encryption stage, while the overall execution time is also strongly influenced by the AI request-processing time and other auxiliary operations.

4.2.6. NIST Statistical Tests

An additional evaluation of the proposed encryption scheme was performed using the NIST SP 800-22 test suite. This test suite is used to assess the quality of randomness and the statistical reliability of the algorithm by applying a set of 15 tests comprising a total of 188 subtests due to the internal structure of some of the individual tests. The tests were conducted using the main color test image, Peppers, with a resolution of 512 × 512 pixels, corresponding to a total of 6,291,456 bits. These data were divided into six independent sequences of 1,048,576 bits each, in accordance with the minimum sample size recommended by NIST. Two separate evaluations were performed for images encrypted using the chaotic and hyperchaotic systems, respectively, with parameters generated by the OpenAI AI model. The obtained p-values at the selected significance level are presented in Table 11 for the chaotic system and in Table 12 for the hyperchaotic system.

Table 11. NIST statistical test for encryption with chaotic system.

Test	Subtests	p-Value	Verdict
Frequency	1/1	0.6460	PASS
Block Frequency	1/1	0.4349	PASS
Cumulative Sums (fwd + bwd)	2/2	0.5980	PASS
Runs	1/1	0.3607	PASS
Longest Run of Ones	1/1	0.4588	PASS
Binary Matrix Rank	1/1	0.5708	PASS
Discrete Fourier Transform	1/1	0.5310	PASS
Non-overlapping Template Matching	141/148	0.4988	7 FAILED
Overlapping Template Matching	1/1	0.5738	PASS
Maurer’s Universal Statistical	1/1	0.6609	PASS
Approximate Entropy	1/1	0.2094	PASS
Random Excursions	8/8	0.4962	PASS
Random Excursions Variant	16/18	0.3946	2 FAILED
Serial (first+ second)	2/2	0.5674	PASS
Linear Complexity	1/1	0.4850	PASS

Table 12. NIST statistical test for encryption with hyperchaotic system.

Test	Subtests	p-Value	Verdict
Frequency	1/1	0.4646	PASS
Block Frequency	1/1	0.4732	PASS
Cumulative Sums (fwd + bwd)	2/2	0.4798	PASS
Runs	1/1	0.4084	PASS
Longest Run of Ones	1/1	0.6166	PASS
Binary Matrix Rank	1/1	0.5147	PASS
Discrete Fourier Transform	1/1	0.5183	PASS
Non-overlapping Template Matching	139/148	0.5064	9 FAILED
Overlapping Template Matching	1/1	0.3113	PASS
Maurer’s Universal Statistical	1/1	0.4179	PASS
Approximate Entropy	1/1	0.6135	PASS
Random Excursions	7/8	0.4815	1 FAILED
Random Excursions Variant	18/18	0.5958	PASS
Serial (first+ second)	2/2	0.4536	PASS
Linear Complexity	1/1	0.6291	PASS

The results presented in Table 11 and Table 12 show that the algorithm successfully passes 179 out of a total of 188 tests (95.2%) when the chaotic system is used and 178 out of 188 tests (94.7%) when the hyperchaotic system is employed. The obtained mean p-values, equal to 0.4917 for the chaotic system and 0.5114 for the hyperchaotic system, are close to the theoretically ideal value expected for truly random sequences. For both configurations, only one reproducible weakness can be identified, occurring in the Non-overlapping Template Matching test, whereas all remaining tests are successfully passed. The failures in the Non-overlapping Template Matching test should not be interpreted as evidence of a structural weakness of the cipher, but rather as a consequence of the test configuration: this test comprises 148 independent subtests (one per 9-bit aperiodic template), and with only six sequences the NIST proportion criterion (minimum pass proportion ≈ 0.868 at α = 0.01) is violated as soon as a single sequence fails a given template. Since the probability that at least one of six sequences fails a subtest by chance is 1 − 0.99⁶ ≈ 5.9%, approximately 148 × 0.059 ≈ 8.7 template failures are expected for a truly random source, which is fully consistent with the observed 7 and 9 failures; moreover, the failed subtests are distributed over different templates in the two configurations, and their p-values are not extreme, indicating no systematic bias toward any particular bit pattern.

4.2.7. Comparative Analysis

A comparative analysis was performed with other contemporary cryptographic methods and image encryption algorithms. The comparison was conducted using the widely employed Peppers image (512 × 512 pixels). For the methods reported in the cited studies, the published metric values were used, while an average value was calculated for the correlation metric. For the proposed architecture, the reported metric values represent averages obtained across the different AI models and are presented separately according to the type of nonlinear dynamical system employed, namely, the chaotic or hyperchaotic system. The comparative results are presented in Table 13.

Table 13. Comparative analysis results.

		Entropy	Correlation	NPCR	UACI	Key Space
Proposed	Chaos	7.9993	0.0009	99.6079	33.4594	>x0 × 2200
	Hyperchaos	7.9993	0.0008	99.6166	33.4780	>x0 × 2200
Ref. [62] (2025)		7.9998	0.0054	99.6177	33.4660	2498
Ref. [63] (2025)		7.9992	0.0006	99.6057	33.4702	2597
Ref. [64] (2024)		7.9993	0.0004	99.6115	33.4693	>2256
Ref. [65] (2025)		7.9993	0.0053	99.6103	33.4689	2465
Ref. [66] (2024)		7.9992	0.0067	99.6115	33.5177	2360
Ref. [67] (2025)		7.9994	0.0321	99.6119	33.4340	2512
Ref. [68] (2025)		7.9991	0.0013	99.6072	33.4666	2395
Ref. [69] (2026)		7.9993	0.0023	99.6070	33.4740	2402

From the performed comparison, it can be concluded that the proposed encryption scheme is comparable in performance to other contemporary image encryption algorithms reported in reputable scientific publications, while outperforming some of them with respect to certain evaluation metrics. Regarding the key-space value, only the estimate corresponding to the basic variant of the proposed algorithm is reported. This value does not take into account the extended configuration in which a completely different set of system parameters is used to generate the keystream for the second diffusion stage.

5. Discussion

The proposed architecture of the encryption algorithm follows a modular structure in which the elements associated with artificial intelligence are implemented as separate subroutines. In this manner, the main encryption procedure allows different AI models to be employed without requiring substantial modifications to the remaining stages of the algorithm. This is demonstrated through the evaluation of four AI models deployed on different platforms. The obtained results confirm that the proposed architecture is not restricted to a single provider or to a specific API structure. Such modularity represents an important architectural property, as it enables one AI model to be replaced by another.

A major advantage of the proposed integration is the reduction in direct human involvement in the generation of the encryption key. Manual selection of encryption parameters or their fixed specification in conventional implementations represents a potential vulnerability arising from the experience, decisions, and possible errors of the user. Automated parameter generation reduces the probability of repeatedly using identical, predictable, or improperly selected parameters of the chaotic systems, since the human factor is generally regarded as a weak element in information protection systems.

On the other hand, despite the advantages of AI-based parameter generation, the use of AI introduces an additional attack surface into the encryption architecture. To mitigate this risk, the AI model should not be regarded as an independent source of cryptographic entropy or as a secret key. For this reason, in the proposed architecture, the AI-generated parameters are subjected to strict numerical validation. In addition, only numerical values are supplied to the AI model. In this way, the architecture preserves its adaptive capabilities while preventing dependence on the behavior and/or predictability of the AI model. The implemented modularity of the architecture, including restricted numerical inputs, validation, retry mechanisms, and other fallback procedures, reduces the risks associated with malformed responses.

In all chaos-based image encryption algorithms, the admissible ranges of the system parameters are of particular importance. The use of an AI model cannot be considered equivalent to a complete verification of the dynamical behavior of the resulting system; however, the obtained parameter values preserve the chaotic or hyperchaotic regime and generate trajectories suitable for the construction of permutation sequences. Therefore, within the proposed architecture, the AI module does not replace the mathematical conditions imposed by the selected dynamical system or by the algorithm as a whole. Instead, it operates within predefined constraints, while the validation module ensures compliance with these constraints. At the same time, the AI module introduces additional computational and communication operations, which is characteristic of chaos-based encryption algorithms incorporating AI functionality and, in practice, makes direct comparison among them less meaningful. It should be emphasized that, since the AI API response time (1.2–3.8 s) exceeds the actual encryption time (~0.05 s) by roughly two orders of magnitude, the proposed scheme is intended for offline or asynchronous encryption of still images and stored data, and is not suitable in its current form for real-time applications such as video streaming, unless the parameter generation is performed once and reused for a batch of images or precomputed in advance.

Nevertheless, a comparison with contemporary image encryption schemes was performed, which clearly demonstrates the favorable characteristics of the proposed architecture and further confirms the results presented in the preceding sections. It is noteworthy that, although the results obtained for the MRI image are somewhat lower, they still remain quite satisfactory, particularly considering that the implemented algorithm has not been specifically optimized for medical images. Even better results can be achieved by introducing an additional diffusion stage, such as CBC chain-like diffusion. However, as is well known, this may lead to degraded performance under noise and data-cut attacks. For this reason, it was decided that preserving robustness to noise is of greater practical importance, since, during real-world image transmission, the presence of noise cannot be completely excluded.

6. Conclusions

This paper presents an approach and architecture for integrating artificial intelligence functionalities into an image encryption algorithm based on chaotic dynamics and a Fibonacci Q-matrix. In the proposed modification, the generated parameters are determined from numerical characteristics of the input image, thereby introducing a dynamic behavior into the encryption procedure. Consequently, different input images may result in different parameter sets for the chaotic or hyperchaotic system, as well as different Fibonacci matrices. The role of AI is particularly important in this context, as it automates the interpretation of the supplied image characteristics and generates the required numerical values without the need for manual parameter selection.

Four AI models were evaluated within the proposed architecture. The experimental results obtained for both the chaotic and hyperchaotic systems demonstrate that the encrypted images achieve values of the principal evaluation metrics close to their theoretical maxima, while maintaining low correlation between neighboring pixels. These results confirm that the proposed AI-assisted parameter-generation approach can be successfully applied to both types of dynamical systems. Furthermore, the AI-generated parameter values can also be effectively employed during the inverse procedure, enabling successful recovery of the encrypted images.