A parallel image encryption algorithm using intra bitplane scrambling

Abstract

More and more privacy-sensitive images have been produced daily. Chaotic encryption guarantees that only the targeted receiver can obtain the raw image. Many works perform encryption on bit-level for better permutation but incur an unbearable time consumption caused by generating additional 3D coordinates. High-dimensional chaotic system, suitable for encrypting images, needs to iterate repeatedly for several rounds, resulting in low encrypting efficiency. This paper proposes a parallel image encryption algorithm using intra bitplane scrambling. Four threads are utilized to encrypt the images in bit-level during the permutation, where each thread scrambles two bitplanes. In diffusion, we build multiple threads to generate keystream segments to reduce encryption time. We make cryptographic analyses and compare the encryption speed with the advanced works, demonstrating that our scheme is secure and efficient.

Full text

Available online at www.sciencedirect.com
ScienceDirect
Mathematics and Computers in Simulation 204 (2023) 71–88
www.elsevier.com/locate/matcom
Original articles
A parallel image encryption algorithm using intra bitplane scrambling
Wei Songa, Chong Fua,b,∗, Yu Zhengc,1, Ming Tied, Jun Liua, Junxin Chene
aSchool of Computer Science and Engineering, Northeastern University, Shenyang 110819, China
bEngineering Research Center of Security Technology of Complex Network System, Ministry of Education, China
cDepartment of Information Engineering, The Chinese University of Hong Kong, Sha Tin, Hong Kong Special Administrative Region
dScience and Technology on Space Physics Laboratory, Beijing 100076, China
eCollege of Medicine and Biological Information Engineering, Northeastern University, Shenyang, 110819, China
Received 14 September 2021; received in revised form 4 May 2022; accepted 31 July 2022
Available online 9 August 2022
Abstract
More and more privacy-sensitive images have been produced daily. Chaotic encryption guarantees that only the targeted
receiver can obtain the raw image. Many works perform encryption on bit-level for better permutation but incur an unbearable
time consumption caused by generating additional 3D coordinates. High-dimensional chaotic system, suitable for encrypting
images, needs to iterate repeatedly for several rounds, resulting in low encrypting efficiency. This paper proposes a parallel
image encryption algorithm using intra bitplane scrambling. Four threads are utilized to encrypt the images in bit-level during
the permutation, where each thread scrambles two bitplanes. In diffusion, we build multiple threads to generate keystream
segments to reduce encryption time. We make cryptographic analyses and compare the encryption speed with the advanced
works, demonstrating that our scheme is secure and efficient.
© 2022 International Association for Mathematics and Computers in Simulation (IMACS). Published by Elsevier B.V. All rights
reserved.
Keywords: Parallel image encryption; Chaos; Multi-threads; Intra bitplane scrambling
1. Introduction
Images are widely utilized to transmit information but are often privacy-sensitive. Many owners are willing to
send their images to close friends rather than sharing them in public. It is vital to protect the privacy of sensitive
images, such as medical X-ray film. The traditional encryption schemes (e.g., DES, AES) do not encrypt images
fast since “everything” encrypted by these schemes is considered as textual messages. The intrinsic features of
images, such as bulk data, high redundancy, and strong correlation among adjacent pixels, are ignored, resulting in
low encrypting efficiency.
Chaotic dynamic systems have multiple properties, which can be used in the cryptosystem. The initial keys
of cryptosystem can be constructed through initializing values and parameters of chaotic systems. The pseudo-
random behavior and unstable orbits are good at generating pseudo-random numbers. We can utilize the values,
which are extremely sensitive to initial keys, in the diffusion stage when encrypting the plaintext. The basic
∗Corresponding author at: School of Computer Science and Engineering, Northeastern University, Shenyang 110819, China.
E-mail address: fuchong@mail.neu.edu.cn (C. Fu).
1Work started when Yu was affiliated with NEU, China.
https://doi.org/10.1016/j.matcom.2022.07.029
0378-4754/© 2022 International Association for Mathematics and Computers in Simulation (IMACS). Published by Elsevier B.V. All rights
reserved.

W. Song, C. Fu, Y. Zheng et al. Mathematics and Computers in Simulation 204 (2023) 71–88
permutation–diffusion architecture for image encryption was proposed by Fridrich [16]. Numerous following
works [8–10,14,15,19,20,25,26,40,45,48] have been proposed by building atop this architecture. Very recently,
hybrid protection for Image ROI [27] integrates chaos theory and neural network [5] for acquiring stronger security
and better functionality in a lightweight cryptographic system. Assisted by advanced learning algorithms, prevailing
works [18,30–34] would be applied for improving various application scenarios with particularity.
1.1. Related works
By operating on different data types, chaotic schemes on images are based on encryption in pixel-level or bit-
level. In permutation stage, pixel-level proposals perform encryption and decryption on pixels, i.e., an image is
considered as a set of pixels. They remove the correlation of adjacent pixels and output shuffled images via pixel
randomization. Sorting algorithm, cyclic shift, and pixel swapping mechanism [1,21,28,39] are common operations
on shuffling the pixels. Yet, the pixel value and the histogram statistics remain unchanged after this kind of
permutation/shuffling [13,48]. Bit-level works tackle this problem by converting an image to a 3D bit matrix but
spend lots of time (about eight times) to generate scrambled coordinates. In each work, one pixel is composed of
eight bits, where one bit is the basic unit of operational data by generalizing some operations above [6,7,36,43,46].
All bits at the same location in each pixel construct a bitplane. Since the higher four bitplanes affect the image
visualization mostly, many high-intensive algorithms allow protecting the higher half of planes [35,42] for reducing
time. However, these works still need to generate a large set of scrambled coordinates, which remain time-
consuming. And simply cyclic shuffling the bits in one bitplane remains the distribution unchanged while scrambling
the whole 3D bit matrix costs a large amount of time.
The question is how to change the distribution/statistics on bitplanes and reduce the time of permutation in the
meantime. Different from existing permutation algorithms [21,28,39,48], we use four lower bitplanes to mask the
higher four bitplanes in permutation stage. Four threads are created to shuffle eight bitplanes in a parallel manner.
In each thread, we execute permutation between two randomly-chosen bitplanes. Four threads are executed in the
meantime, showing superior efficiency for scheduling threads.
In the diffusion stage, bit-level encryption is vulnerable to chosen-plain attacks [39]. Traversing the bit sequence
costs eight times longer than the pixel sequence. However, this may incur a much time burden because sometimes
the image size is large and there are usually several rounds of diffusion. Thus, we still adopt the pixel-level
diffusion [24,29,48] after bit-level permutation. Besides, high-dimensional chaotic systems are used in the above
algorithms for better chaotic behavior but resulting in time-consuming. For achieving fast diffusion, we split the
keystream into segments, each of which is parallelly generated.
1.2. Our contribution
This paper proposes a fast parallel encryption algorithm by combining bit-level permutation and pixel-level
diffusion. The technical contributions are summarized below.
•Our proposed scheme speeds up both the permutation and the diffusion operation. We design a parallel bit-level
permutation algorithm by considering the intrinsic features of digital images. In diffusion stage, the generation
of keystream is a time-consuming process. To address this issue, we use multi-threading technology to generate
keystream parallelly to reduce the running time. We divide the data operated by each thread reasonably,
which ensures that there are no data disorder problems. Good thread control mechanism also ensures thread
synchronization in permutation and diffusion stage.
•There are four threads in diffusion stage. The key for Thread0is randomly assigned. The keys for other threads
are perturbed by the permutation keys, ensuring that different threads generate different segments.
•We conduct the security analyses in both theory and experiments and compare our work with state-of-the-art
ones [2,22,28,39,44,48], showing high efficiency.
Roadmap. The remainder of this paper is organized as follows. In Section 2, we introduce the proposed parallel
permutation scheme. The accelerated diffusion phase is designed in Section 3. The Section 4summarizes the entire
encryption process. In Section 5, we analyze computational complexity and provide comparison results. Section 6
analyzes the security of the proposed scheme. At last, Section 7concludes our paper.
72

W. Song, C. Fu, Y. Zheng et al. Mathematics and Computers in Simulation 204 (2023) 71–88
Fig. 1. The binary images of eight bitplanes.
2. Designing parallel permutation
This section is organized as follows: discuss the original motivation to design this algorithm; explain how our
permutation works; elaborate on the entire permutation process.
An image can be considered as a set of eight bitplanes. A pixel value Pv is represented by,
Pv=
7

i=0
2i×bpi,(1)
where bpi∈ {0,1}. From the Eq. (1), it can be calculated that the higher four bitplanes have a high probability of
accounting for 94.1% of image information. It means that the higher four bitplanes have more impact on human
visual system than lower four bitplanes. It is seen as an intrinsic feature of the bit distribution of images in [47].
Fig. 1 shows the Lena image in eight bitplanes. It can be seen that the higher bitplanes contain the majority of the
visually significant data, and the lower four bitplanes act as random noises. These intrinsic features of bit distribution
inspire us to randomly put lower bitplanes in the higher position to hide plaintext information. Besides the features
mentioned above, most bits at the same position in 7th and 8th bitplanes have opposite values, showing that the
two bitplanes have a strong correlation [47]. Therefore, we exchange bits of higher bitplanes with lower bitplanes
to remove the correlation between higher bitplanes.
For parallel bit-level permutation, eight bitplanes are randomly divided into four groups, in which two bitplanes
exchange bits as shown in Fig. 2. The bit-level permutation contains two types of plane-grouping. In the first
round, we divide eight bitplanes into two sets of size 4, one with higher bitplanes and the other with lower
bitplanes. Fig. 2(a) shows an example of first-stage permutation. In particular, different bitplanes are combined to
be [(bp7↔bp1),(bp6↔bp0),(bp5↔bp3),(bp4↔bp2)]. To hide private plaintext, we exchange bits between two
bitplanes derived from different sets as shown in Fig. 2(b).Fig. 2(a) shows that bit-exchanging in each group does
not affect others due to no data sharing among four group, so there is no data disorder during parallel permutation.
After the first round of permutation, the statistical information of plain-image has been successfully masked. Without
sensitive statistical information, we can group any two bitplanes in the following rounds.
2.1. Grouping bitplanes with logistic map
We employ the chaotic logistic map to assign the eight bitplanes into four groups randomly. Mathematically, the
map is defined by,
xn+1=µxn(1 −xn),(2)
73

W. Song, C. Fu, Y. Zheng et al. Mathematics and Computers in Simulation 204 (2023) 71–88
Fig. 2. Our parallel bit-level permutation algorithm.
Fig. 3. The logistic map used in permutation stage.
Table 1
Function parameter definition in Alg. 1.
Parameter Definition
lgInitbpgrp The initial values of the logistic map (i.e. x0) used in bitplane grouping.
pmRnd The current permutation round.
bp The identifiers of eight bitplanes, it is an array bp = {0,1,2,3,4,5,6,7}.
nub The number of unselected bitplanes, and its initial value is 8.
hnub The half of nub, and its initial value is 4.
where µ∈(0,4] is the control parameter. Fig. 3 shows the bifurcation diagram and Lyapunov exponents of logistic
map. The logistic map enters chaotic state, when the Lyapunov exponent is positive. As a result, the value of µis
set to 4 for the best chaotic behavior.
The detailed procedure for grouping bitplanes is depicted in Alg. 1. And Table 1 shows the function parameter
definition in Alg. 1.
Before selecting bitplanes, we first pre-iterate Eq. (2) for T0times to avoid the harmful effect of the transitional
procedure, where T0is a user-defined value. In our algorithm, we declare the data type of the state variables as
double precision, which has a 15-digit precision. Then we quantize the generated values to get two bitplanes bp1
and bp2. The range of bp1,bp2 depends on the current encryption round pmRnd. After the selection, we remove
bp1 and bp2 from the array bp. After selecting two bitplanes, the value of nub is decreased by 2 and the value of
hnub is decreased by 1. bp1 and bp2 represent the two selected bitplanes. Invoking the Alg. 1for four times in
each round, we obtain four groups of bitplanes to be scrambled.
74

W. Song, C. Fu, Y. Zheng et al. Mathematics and Computers in Simulation 204 (2023) 71–88
Algorithm 1 The random grouping of bitplanes.
Input: lgInitbpgrp,pmRnd,bp,nub,hnub
Output: bp1,bp2
1: function BP GRP (lgInitbpgrp,pmRnd,bp,nub,hnub)
2: x0←lgInitbpgrp and pre-iterate logistic map for T0times
3: Iterate logistic map for two times →x1,x2
4: if pmRnd == 0then
5: bp1←bp[(int 64)(x1×1015 ) mod hnub]
6: Swap the values of bp1 and bp[hnu b −1]
7: bp2←bp[4 +(int 64)(x2×1015 ) mod hnub]
8: Swap the values of bp2 and bp[4 +hnu b −1]
9: hnub − = 1, and nub − = 2
10: else
11: bp1←bp[(int 64)(x1×1015 ) mod nub]
12: Swap the values of bp1 and bp[nub −1]
13: nub − = 1
14: bp2←bp[(int 64)(x2×1015 ) mod nub]
15: Swap the values of bp2 and bp[nub −1]
16: nub − = 1, and hnub − = 1
17: end if
18: end function
Table 2
Function parameter definition in Alg. 2.
Parameter Definition
(bpm,bpn) The two bitplanes to be shuffled.
lgInitexBit The initial value of logistic map used in bit exchanging.
lenBs The length of the bit sequence converted from a bitplane.
2.2. Exchanging bits between two bitplanes
A 256-grayscale image of size M×Ncan be considered as a 3D bit matrix of size M×N×8 in bit-level.
In bit-level permutation algorithms, calculating the bit positions in a 3D space is time-consuming. To simplify the
calculation, dimensionality reduction is performed on the 3D bit matrix. We use BBD [49] to decompose image
data to obtain eight 2D bitplanes. Then each 2D bitplane converts to a 1D bit sequence. The i-th 1D bit sequence
is represented by,
bpi= {bpi
0,bpi
1,...,bpi
M×N−1}.(3)
The detailed operation of exchanging bits between two bitplanes is summarized in Alg. 2. And Table 2 shows the
function parameter definition in Alg. 2. For each iteration, we extract a pseudo-random integer in range [0,lenBs−1]
from the current state of logistic map. Assuming that we get a value pos after extraction, then we swap the values
of current bit bpm
iand the target bit bpn
pos . The outputs of Alg. 2are two mutual permuted bitplanes bp P er mmand
bp P er mn.
2.3. The permutation process
This subsection constructs the entire parallel permutation algorithm, as shown in Alg. 3. This algorithm needs
to be run on a CPU with at least four threads. As aforementioned, lg I ni tbp gr p is the initial value of the logistic
map used in Alg. 1. First, eight bitplanes bps are divided into four groups. Secondly, we create four threads and
suspend them as there are many thread-related parameters that need to be set before execution. We set thread
75

W. Song, C. Fu, Y. Zheng et al. Mathematics and Computers in Simulation 204 (2023) 71–88
Algorithm 2 Exchanging bits between two bitplanes.
Input: bpm,bpn,lgInitexBit,lenBs
Output: bpPermm,bpPermn
1: function BP EXCHANGEBITS(bpm,bpn,lgInitexBit,lenBs)
2: Initialize the bit position pos to 0
3: x0←lgInitexBit
4: Preiterate logistic map for T0times
5: x0←xT0
6: for i=0 to lenBs −1do
7: Iterate the logistic map to generate a new value xi
8: pos ←(int 64)(xi×1015) mod l en Bs
9: Swap the bit values of bpm
iand bpn
pos
10: end for
11: bpPermm←bpmand bpPermn←bpn
12: end function
affinity to guarantee that each thread runs on different processors. Then we set thread function parameters to make
different threads smoothly perform the bits scrambling operation in each group. For each thread, the logistic map
for exchanging bits needs an initial value, which is denoted by lgInitk
exBit,k∈[0,3]. At last, the threads’ execution
is resumed. Then, bit-planes from four groups are shuffled in a parallel way. The multi-thread programming is
implemented with the help of Windows API. The outputs are eight shuffled bitplanes bpPerms.
Algorithm 3 The proposed parallel bit-level permutation.
Input: lgInitbpgrp,(lgInitk
exBit,k∈[0,3]),pmRnd,lenBs,bp,nub,hnub
Output: bpPerms
1: function BP PER M UTATI ON (lgInitbpgrp,(lgInitk
exBit,k∈[0,3]),pmRnd,bp,lenBs)
2: for i=0 to 3 do
3: BP GRP (lgInitbpgrp,pmRnd,bp,hnub,nub)
4: end for
5: Get four group of bitplanes, (gbp[k]1 ↔gbp[k]2)
6: for k=0 to 3 do
7: Create Threadkand suspend
8: SetThreadPriority and SetThreadAffinityMask
9: Assign thread function and its argument
10: end for
11: spawn
12: Resume the execution of Threadkand BPEXCHANGEBITS(bpgbp[k]1 ,bpgbp[k]2,lgInitk
exBit,lenBs)
13: sync
14: end function
To measure the scrambling effect, we carry out a histogram analysis, and the results are shown in Fig. 4.
Figs. 4(a),4(c), and 4(e) show the plain-image, the permuted image obtained using three rounds of sorting-
based permutation [21], and our proposed algorithm, respectively, and their corresponding histograms are shown in
Figs. 4(b)–4(f), respectively. It can be seen that the histogram remains unchanged when the permutation is pixel-
level, while the histogram of the proposed algorithm is flatter. This proves that our scheme can hide the statistical
properties of images.
Table 3 lists the time required to execute three rounds of the proposed algorithm and the comparison algorithms.
The size of the test image is 512 ×512. Fig. 4 and Table 3 show that our proposed parallel bit-level offers the best
trade-off between permutation efficiency and effect.
76

W. Song, C. Fu, Y. Zheng et al. Mathematics and Computers in Simulation 204 (2023) 71–88
Fig. 4. The histogram of the image after permutation. (a), (c), and (e) are the plain-image, the scrambled image obtained using three
rounds of sorting-based permutation, and our proposed algorithm, respectively. Their corresponding histograms are shown in (b), (d) and (f),
respectively.
Fig. 5. The generation of keystream in parallel mode.
Table 3
The time consumption of permutation operation of different algorithms.
Our work Ref. [48] Ref. [21] Ref. [39] Ref. [28]
Time(s) 0.049 0.183 0.039 0.030 0.024
Type bit-level bit-level pixel-level pixel-level pixel-level
3. The accelerated pixel-level diffusion
In this section, we introduce a parallel strategy for speeding up the diffusion process.
The CBC (Cipher Block Chaining) mode is usually used in diffusion stage. It allows the current pixel to be
affected by the previous ones. However, the mode brings difficulties in parallel design. The reason is that the image
data handled by different threads affects each other when encrypting the whole image. To keep CBC mode, the
thread which handles current image data block needs to wait for the task completion signal from another thread
which handles previous image data block. It is very time-consuming and complicated to implement the thread
synchronization and data consistency during the thread waiting. Therefore, it is more reasonable to optimize the
time consumed by the iteration of chaotic systems. We consider a novel parallel manner from another perspective,
i.e., generating the keystream parallelly. As shown in Fig. 5, we split the whole keystream into four sub-keystreams,
in which no keystream elements are shared. Then, we use multiple threads to generate sub-keystreams in parallel
and connect all segments for yielding the original keystream.
The Lorenz system, which has complex dynamical behavior, is used to generate chaotic sequences. Mathemati-
cally, the system is described by













dx
dt =σ(y−x),
dy
dt =x(ρ−z)−y,
dz
dt =x y −βz,
(4)
where x,y,zare state variables, and σ, β, ρ are parameters. The system exhibits chaotic behavior when σ=10, β =
8/3, ρ =28. The initial values of the system (x0,y0,z0) can uniquely determine a chaotic trajectory by iterating
the chaotic system, so they are used as the encryption keys. We use Runge–Kutta 4th order method to solve the
ordinary differential equation with a step size of h=0.0005.
The Alg. 5describes the proposed accelerated diffusion algorithm, in which function parameter definition is
shown in Table 4. As we have four threads, the initial values of the Lorenz system for each thread should be
different so as to generate different sub-keystreams. To do that, we first randomly take three of the four current
values of (lgInitk
exBit,k∈[0,3]) and generate their permutations. There are C3
4·A3
3=24 possible permutations,
77

W. Song, C. Fu, Y. Zheng et al. Mathematics and Computers in Simulation 204 (2023) 71–88
Table 4
Function parameter definition in Alg. 5.
Parameter Definition
dtPm The 1D array reshaped from the scrambled image data.
lenPm The length of dtPm.
(lxk
0,lyk
0,lzk
0) The initial values of the Lorenz system handled by Threadk,k∈[0,3], where (lx0
0,ly0
0,lz0
0) are user-defined values.
and the choice depends on the current value of lgInitbpgrp. Secondly, we use the selected values to perturb the
(lx0
0,ly0
0,lz0
0) as shown in lines 6 −11 of Alg. 4. Here P t V al , whose value is suggested to be in the range of
[5,20], is used to control the perturbation magnitude to keep the system being chaotic. The above operations are
repeated for three times to generate the different initial values of (lxk
0,lyk
0,lzk
0),k∈[1,3]. The detailed perturbation
process is depicted in Alg. 4. Next, the four threads start generating the sub-keystreams in parallel. After merging
all sub-keystreams into a whole keystream ks, we use it to encrypt the scrambled image. c−1is a pre-defined value
that can be any value in the range of [0,255]. Our choice is 127, and Lis the number of gray levels in the input
image (for a 24-bit RGB color image, L=256).
Algorithm 4 The initialization of Lorenz systems in diffusion stage.
Input: lgInitbpgrp,(lgInitk
exBit,k∈[0,3]),lx0
0,ly0
0,lz0
0
Output: The initialized values of Lorenz systems for the other three threads
1: function SE TINITVAL LOR (lgInitcur
bpgrp,(lgInitk
exBit,k∈[0,3]),lx0
0,ly0
0,lz0
0)
2: Generate a table lgTab[24][3] of the key permutations of (lgInitk
exBit,k∈[0,3])
3: for i=1 to 3 do
4: Iterate the logistic map →lgInitcur
bpgrp
5: sltn ←(int 64)(lgInitcur
bpgrp ×1015) mod 24
6: (lx0
0>0)? f lagx= −1:f l agx=1
7: lxi
0←lx0
0+f lagx·((i nt 64)(lgTab[sltn][0] ×1015) mod P t V al )
8: (ly0
0>0)? f lagy= −1:f l agy=1
9: lyi
0←ly0
0+f lagy·((i nt 64)(lgTab[sltn][1] ×1015) mod P t V a l)
10: (lz0
0>25)? f lagz= −1:f lagz=1
11: lzi
0←lz0
0+f lagz·((i nt 64)(lgTab[sltn][2] ×1015) mod P t V al )
12: end for
13: end function
4. The propsed cryptosystem
4.1. Encryption process
Fig. 6 shows the parallel encryption structure. The entire encryption process can be described as follows.
Step 1: Input the plain-image and decompose it into eight bitplanes.
Step 2: Invoke Alg. 3to carry out bit-level permutation in parallel.
Step 3: Invoke Alg. 5to generate keystream in parallel and perform pixel-level diffusion.
Step 4: Repeat Step 2 and Step 3 and get the cipher-image.
4.2. Decryption process
The decryption process is roughly the reverse of the encryption process. For the decryption of diffusion, we first
need to iterate the five logistic maps to the state where the permutation ends. The intermediate variables are saved
for the decryption of permutation. Then we use Alg. 4to perturb the initial values of Lorenz system, i.e. diffusion
key. Similar to the encryption, the decryption process is carried out in parallel. Particularly, the inverse of line 17
of Alg. 5is given by
dtPm[i]= {ks[i]⊕ci⊕ci−1+L−ks[i]}mod L.(5)
78

W. Song, C. Fu, Y. Zheng et al. Mathematics and Computers in Simulation 204 (2023) 71–88
Algorithm 5 The proposed accelerated diffusion algorithm.
Input: lgInitbpgrp,lgInitk
exBit,lx0
0,ly0
0,lz0
0,dtPm,lenPm
Output: EncryptedImgData
1: function IMGDIFF US I ON(lgInitbpgrp,lgInitk
exBit,lx0
0,ly0
0,lz0
0,dtPm,lenPm)
2: CreateThreads and suspend
3: Set priority and affinity mask for each thread
4: SE TINITVAL LOR (lgInitbpgrp,lgInitk
exBit,lx0
0,ly0
0,lz0
0)
5: Assign thread function and its argument
6: spawn
7: Resume the execution of Threadkand generate [seq diffusion k·len P m
4,seq diffusion(k+1)·l en P m
4−1]
8: for i=k·len P m
4to (k+1)·len P m
4−1do
9: while 
seq diffusioni
>1do
10: seq diffusioni/= 10
11: end while
12: ks[i]=(int 64)(|seq diffusion[i]|×1015 ) mod L
13: end for
14: sync
15: for i=0 to lenPm −1do
16: ci←ks[i]⊕ {[dtPm[i]+ks[i]] mod L} ⊕ ci−1
17: end for
18: end function
5. Computational complexity analysis and encryption performance evaluation
In this section, we first analyze and compare the computational complexity of our parallel permutation algorithm
and three most commonly used permutation algorithms, and then we compare the encryption performance with
three state-of-the-art encryption algorithms.
5.1. The computational complexity of permutation stage
To demonstrate the advantage of our permutation method in terms of computational complexity, we compare it
with the four most commonly used permutation algorithms [21,28,39,48]. The algorithm in [48] works at bit-level
and the others are pixel-level. In [48], the image is considered as a 3D matrix with size of 8 ×M×N, and
the bit-level permutation is performed according to the permutation coordinates generated by 3D cat map, so the
computational complexity is Θ(8 ×M×N). Suppose that we want to encrypt an image of size M×Nwith
gray-level 256. In [21], a plain-image is shuffled by sorting-based permutation, with computational complexity
Θ((M×N) log(M×N)). In [39], some hybrid operations including sorting and row/column shifting are used to
shuffle the plain-image, and the computational complexity is Θ((M×N) log(M×N)). And in [28], each pixel swaps
its position with a pixel pseudo-randomly chosen from all the pixels after it, so the computational complexity is
Θ(M×N).
As for our proposed parallel permutation algorithm, the running time is the maximum of the time of the four
sub-computations, because the four grouped bitplanes are joined in parallel. Besides that, there are some extra
operations, such as thread creation and the decomposition/composition of bitplanes, consuming time of P. As a
result, our method has a running time of Θ(M×N+P) as the size of each bitplane is M×N, thus saving lots
of time compared with Ref. [48]. And the test results reported in Table 3 prove our analysis.
5.2. Analysis of time consumption in the diffusion stage
Specifically, the diffusion stage comprises two primary phases, namely the generation of keystream and the
encryption of image. In the first phase, we usually choose to use high-dimensional chaotic systems for achieving a
79

W. Song, C. Fu, Y. Zheng et al. Mathematics and Computers in Simulation 204 (2023) 71–88
Fig. 6. The proposed parallel encryption structure.
Fig. 7. Different working modes for multiple subtasks.
high encryption strength. The reason is that high-dimensional chaotic systems exhibit more complicated dynamics
than 1D systems. But the solving of high dimensional partial differential equations (PDEs) is more time-consuming
than 1D chaotic systems, resulting in low encryption efficiency. The computational complexity of keystream
generation is Θ(M×N+T), where Trepresents the number of the pre-iterations of chaotic system. In the
second phase, we use keystreams to encrypt the pixels sequentially from left to right and top to bottom, and the
computational complexity for encrypting an image is Θ(M×N). To ensure the randomness of the keystream
sequences extracted from trajectory of chaotic systems, the data type of the state variables should be declared as
double precision, while the encryption of pixels performs XORing operation on integer values. Thus, the former
one costs more time since the XOR operation is an extremely fast operation.
Fig. 7 can explain how the proposed parallel model reduces the time of keystream generation. To generate
keystreams of equal length, the time consumption of serial mode is the sum of each subtask Ts=T0+T1+T2+T3,
and for parallel mode, the time is only the maximum of all subtasks Tp=max (T0,T1,T2,T3). It is obvious that
Tp<Ts, thus our parallel diffusion algorithm allows less time consumption.
80

W. Song, C. Fu, Y. Zheng et al. Mathematics and Computers in Simulation 204 (2023) 71–88
Table 5
The time consumption of keystream generation and the encryption of pixels.
Image size Keystream generation (s) Encryption of pixels (s)
Logistic map (serial mode) Lorenz system (serial mode) Lorenz system (parallel mode)
512 ×512 0.003 0.005 0.003 0.001
1024 ×1024 0.009 0.016 0.011 0.003
Table 6
The encryption time of different algorithms.
The encryption algorithm Number of encryption rounds The encryption time(s) of different image size
256 ×256 512 ×512 1024 ×1024
Our work 3 0.035 0.130 0.571
Ref. [44] 1 — 0.107 —
Ref. [22] — 0.430 1.100 2.250
Ref. [2] 2 0.621 — —
Table 5 lists the time taken to generate the keystream using different chaotic systems in different modes, and to
encrypt the pixels. The speed of our proposed parallel mode is faster than the serial mode of Lorenz system and
close to that of the serial mode of logistic map, which can be considered as one of the simplest chaotic maps. The
test results show that our parallel method reduces the time required for the keystream generation, which confirms
our previous analysis.
5.3. Encryption performance evaluation
We compare the encryption performance of our proposed algorithm with the state-of-the-art works [2,22,44]. The
experiments run on a computer with Intel(R) Core(TM) i7 −6700 CPU(4 cores, 8 threads) and 8GB RAM. The
developing platform is codeblocks 20.03. The encryption time is listed in Table 6. Notably, the execution time of
our algorithm consists of performing three rounds of encryption, while the encryption time of algorithm [44] does
not include the time spent generating the three 3D Latin cubes, the number of encryption rounds of Ref. [22] is not
given and the encryption time of algorithm [2] consists of performing two rounds of encryption. The encryption
time of our proposed algorithm is the average time of 10 test times, proving the high encryption efficiency.
6. Security analysis
6.1. Key space analysis
The key of our proposed cryptosystem consists of three parts, the initial value of the logistic map used for
bitplanes grouping, the initial values of the four logistic maps for permutation, and initial values of the Lorenz
system. As aforementioned, the data type of all above variables is declared as double precision, which offers 53
bits precision. Therefore, the total key space is 253×7=2371, which is secure enough to resist the brute-force attack
on a modern computer [3].
6.2. Statistical attack analysis
6.2.1. Frequency distribution of pixel values
A good cryptosystem should make the frequency distribution uniform after encryption. We use histogram analysis
to visualize the frequency distribution of pixel values. Fig. 8 shows the frequency distributions of plain-image and
its corresponding cipher-image. As can be seen from this figure, our scheme provides adequate randomization in
frequency distribution of the pixel values in cipher-image.
81

W. Song, C. Fu, Y. Zheng et al. Mathematics and Computers in Simulation 204 (2023) 71–88
Fig. 8. The histograms of plain-image and cipher-image.
Table 7
The information entropy of plain-images and their corresponding cipher-images.
Filename Size Type Information entropy
Plain-image Cipher-image
Lena 512 ×512 Color 7.532720 7.999336
Baboon 512 ×512 Color 7.679608 7.999238
Peppers 512 ×512 Color 7.565483 7.999283
Male 1024 ×1024 Gray 7.575793 7.999829
6.2.2. Information entropy analysis
Information entropy, which is the average minimum number of bits needed to encode a string of symbols, is a
quantitative measure of the randomness and unpredictability of information content. To calculate the information
entropy, we have
H(S)= −
N−1

i=0
P(Si) logP(Si)
2,(6)
where Sis a random variable which has Npossible values S0,S1,...,SN−1, and P(Si) is the probability of Si.
From Eq. (6), it can be seen that information entropy of a random source emitting Nsymbols is logN
2. For instance,
the information entropy of a random image with 256 gray levels is 8 [12]. Therefore, the information entropy of
a cipher-image should be as close as possible to 8 to ensure that an attacker cannot obtain any information about
plain-image by analyzing the frequency of certain characters’ occurrence.
Table 7 lists information entropy of the plain-images and their corresponding cipher-images. We show that
information entropy of cipher-images is very close to 8, which means our algorithm successfully hide the statistical
information of plain-image.
6.2.3. Correlation of adjacent pixels analysis
A pixel in a digital image is not independent of each other, it usually has a strong correlation with adjacent
ones in either horizontal, vertical, and diagonal directions [17,37,38]. Obviously, an effective cryptosystem should
eliminate these correlations. To quantitatively explore the correlation between adjacent pixels in an image, we can
randomly sample 5000 pairs of adjacent pixels from it and use Eq. (7) to calculate the correlation coefficients rxy .
rx y =
1
NN
i=1(xi− ¯x)(yi− ¯y)
(1
NN
i=1(xi− ¯x)2)( 1
NN
i=1(yi− ¯y)2)
,(7)
82

W. Song, C. Fu, Y. Zheng et al. Mathematics and Computers in Simulation 204 (2023) 71–88
Table 8
Correlation coefficients for test images and their corresponding cipher-images.
Image Direction Plain-image Cipher-image
R G B R G B
Lena Horizontal 0.989312 0.981822 0.958012 −0.023050 0.007344 −0.029864
Vertical 0.978200 0.968409 0.933531 0.004765 −0.016220 −0.002356
Diagonal 0.966425 0.957546 0.923295 0.006422 −0.012235 −0.014490
Baboon Horizontal 0.868475 0.769258 0.889039 −0.015995 −0.001557 0.004471
Vertical 0.923147 0.866631 0.907679 0.000646 0.003576 0.029390
Diagonal 0.858655 0.746770 0.841463 0.032847 0.000137 0.032149
Peppers Horizontal 0.969083 0.981142 0.971482 0.010863 −0.019556 0.014533
Vertical 0.962223 0.981469 0.963510 0.005096 0.014960 −0.011490
Diagonal 0.955185 0.968332 0.947219 0.010197 0.007493 −0.008847
Fig. 9. The scatter diagrams of “Lena", (a)–(c) and (d)–(f) are scatter diagrams for horizontally, vertically and diagonally adjacent pixels in
the red channel of the test image and its corresponding cipher-image, respectively.
where xi,yiare the values of the ith pair of adjacent pixels, ¯x=1
NN
i=1xi,¯y=1
NN
i=1yi, and Nis the number
of sampled pixel pairs. We calculate the correlation coefficients of three test images and their corresponding cipher-
images, and the results are shown in Table 8. From this table we can see that there are strong correlations between
adjacent pixels in the plain-images as their correlation coefficients are close to 1. As for the cipher-image, adjacent
pixels are uncorrelated since the correlation coefficients are close to 0.
To visually demonstrate this correlation, we plot the values of all the sampled pixels pairs (xi,yi) in a scatter
diagram. Figs. 9(a)–9(c) and 9(d)–9(f) show the scatter diagrams for horizontally, vertically and diagonally adjacent
pixels in the red channel of the “Lena” test image and its corresponding cipher-image, respectively. It can be seen
that most of the points in Figs. 9(a)–9(c) are clustered around the diagonal, showing there are strong correlations
between adjacent pixels in the plain-image. While the points in Figs. 9(d)–9(f) are evenly distributed throughout the
entire plane, showing that there is practically no correlations between adjacent pixels in the cipher-image. Similar
results can be obtained for the other two color channels.
It can therefore be concluded from the results of the analysis carried out in Section 6.2.1–6.2.3 that our
cryptosystem is robust against frequency analysis.
6.3. Differential attack
Differential attack is a kind of chosen-plaintext attack. Chosen-plaintext attack means that an attacker can choose
arbitrary plaintexts to be encrypted and try to crack the cryptosystem. In differential attack, an attacker uses the
same key to encrypt a certain number of plain-images with little difference which can be constructed by the attacker.
The attacker compares the output cipher-images to find the design flaws in the cryptosystem, then he may create
an algorithm which would allow him to decrypt the cryptosystem. The differential attack is impractical, if the
cryptosystem can produce the same number of completely different cipher-images.
Two criteria, NPCR (the number of pixel change rate) and UACI (the unified average changing intensity) are
used to evaluate the ability of the cryptosystem to resist differential attack. NPCR is defined by,
N P C R =R,G,B
kW
i=1H
j=1D(i,j)
3×W×H×100%,(8)
83

W. Song, C. Fu, Y. Zheng et al. Mathematics and Computers in Simulation 204 (2023) 71–88
Table 9
The modification information of the test images.
Image Color channel Pixel coordinates The change of value
Lena blue (149,452) 210 →211
Baboon red (280,332) 99 →100
Male blue (852,507) 100 →101
Table 10
The random-generated keys used in permutation and diffusion stages.
Permutation stage lgInitbpgrp lgInit0
exBit lgInit1
exBit lgInit2
exBit lgInit3
exBit
0.45367635654491 0.13489635765491 0.43156483545677 0.94561443184614 0.63412476254234
Diffusion stage lx0
0ly0
0lz 0
0
18.9675361237645 10.8235829485923 23.4534759901934
Table 11
The results of NPCR and UACI test for different algorithms.
Image Test criteria Our work Ref. [44] Ref. [22] Ref. [2]
Lena NPCR 0.99602 0.99618 0.99580 0.99620
UACI 0.33465 0.33499 0.33080 0.33391
Baboon NPCR 0.99617 — 0.99590 0.99601
UACI 0.33492 — 0.31560 0.33424
Male NPCR 0.99606 — — —
UACI 0.33452 — — —
where (R,G,B), Wand Hrepresent the three color channels, and the width and height of the image, respectively.
And D(i,j) tells whether the values in the same position in two images C1and C2are the same. It is defined by,
D(i,j)=0i f C1(i,j)=C2(i,j),
1i f C1(i,j)= C2(i,j).(9)
For two random images with 256 gray levels, the theoretical value of N PC R is 99.609%. The UACI is defined by,
U AC I =R,G,B
kW
i=1H
j=1
|C1(i,j)−C2(i,j)|
2L−1
3×W×H×100%,(10)
where Lis gray-level. The theoretical value of UACI is 33.464% with L=256 [11,41].
Considering the worst scenario, we construct two plain-images that differ only by 1-bit in a randomly selected
pixel. And we use the same key to encrypt the two plain-images, and measure the NPCR and UACI between the
two corresponding cipher-images. The modification information of the test images and the values of encryption
keys are listed in Tables 9 and 10. As our algorithm is a parallel image encryption algorithm using intra bitplane
scrambling, the comparable algorithms we choose include a bit-level encryption algorithm [44], a parallel encryption
algorithm [22], and a pixel-level encryption algorithm [2].
Table 11 compares NPCR and UACI of the proposed algorithm with other state-of-the-art algorithms. It shows
that the NPCR and UACI of our algorithm are closer to the theoretical values than other algorithms, demonstrating
better ability to resist differential attack. Our algorithm uses three rounds of encryption to resist differential attack.
6.4. Key sensitivity analysis
To evaluate the key sensitivity of our cryptosystem, we first generate a random secret key consisting of 8 subkeys
as the original key. Then we construct 8 different test keys, each of which differs only in the least significant bit
of one subkey from the original key. Finally, we encrypt a test image using the original key. For instance, we take
the key listed in Table 10 as the original key, and the 8 test keys generated from it are shown in Table 12. We use
84

W. Song, C. Fu, Y. Zheng et al. Mathematics and Computers in Simulation 204 (2023) 71–88
Table 12
The test keys for key sensitivity analysis.
Key No. The change of subkey Key value
(1) — As shown in Table 10
(2) lgInitbpgrp 0.45367635654492
(3) lgInit0
exBit 0.13489635765492
(4) lgInit1
exBit 0.43156483545678
(5) lgInit2
exBit 0.94561443184615
(6) lgInit3
exBit 0.63412476254235
(7) lx0
018.9675361237646
(8) ly0
010.8235829485924
(9) lz 0
023.4534759901935
Fig. 10. Key sensitivity test in decryption process.
Fig. 11. Test results of robustness analysis against noise and data loss. (a) cipher-image with salt & pepper noise (density = 0.05). (b) the
corresponding decrypted image of (a). (c) cipher-image with data loss. (d) the corresponding decrypted image of (c).
Key No. (1) −(9) to decrypt the cipher-image encrypted by Key No. (1). The corresponding decrypted images are
shown in Figs. 10(a)–10(i), respectively. It can be seen that we cannot obtain any information about the plaintext
even if there is only a tiny difference between the decryption and encryption key. It shows that the cipher-image
can be correctly decrypted only under the correct key.
6.5. Robustness to noise and data loss
During real-world transmission, digital image may suffer from noise or data loss. Fig. 11 shows robustness to
noise and data loss. For noise resistance, we add salt & peppers (density = 0.05) to Fig. 8, attaining Fig. 11(a). For
data loss, we crop the same cipher-image with some black pixels as shown in Fig. 11(c). Then, we use Key No.(1)
85

W. Song, C. Fu, Y. Zheng et al. Mathematics and Computers in Simulation 204 (2023) 71–88
to decrypt two images to get decryption in Figs. 11(b) and 11(d). It can be seen that decrypted images are well
recognizable, demonstrating good ability of resisting noise and data loss.
7. Conclusion and future work
In this paper, we propose a parallel image encryption algorithm using intra bitplane scrambling. Through parallel
processing, our idea reduces execution time for generating coordinates in bit-level permutation, and meantime
accelerates keystream generation in diffusion process. Multi-thread permutation brings unavoidable duplicated
operations, such as the pre-iteration of chaotic map, for generating different keystreams in each thread. Experimental
results show that our proposed algorithm can meet the security requirements with high efficiency. Therefore, our
algorithm is very suitable for the protection of high-resolution image.
Outsourcing private data to a remote server is very common. Our solution enables protecting sensitive data before
outsourcing it to an untrusted party. Besides, multiple encryption schemes have been applied to protect the regions
of interest (ROI) in natural images [4,23,27]. In our future work, we would extend this research line, say, using
intrinsic features of bit distribution to mask ROI.
CRediT authorship contribution statement
Wei Song: Conceptualization, Methodology, Software, Writing – review & editing. Chong Fu: Conceptualiza-
tion, Writing – review & editing. Yu Zheng: Writing – review & editing. Ming Tie: Writing – review & editing.
Jun Liu: Writing – review & editing. Junxin Chen: Writing – review & editing.
Declaration of competing interest
The authors declare that they have no known competing financial interests or personal relationships that could
have appeared to influence the work reported in this paper.
Acknowledgments
This work was supported by the National Natural Science Foundation of China (Nos. 62171114, 61773068 and
61671141), the Fundamental Research Funds for the Central Universities (No. N2224001-7) and the National Key
R&D Program of China (No. 2021YFF0306405).
References
[1] J. Ahmad, S.O. Hwang, A secure image encryption scheme based on chaotic maps and affine transformation, Multimedia Tools Appl.
75 (21) (2016) 13951–13976.
[2] M. Alawida, A. Samsudin, J.S. Teh, R.S. Alkhawaldeh, A new hybrid digital chaotic system with applications in image encryption,
Signal Process. 160 (2019) 45–58.
[3] G. Alvarez, S. Li, Some basic cryptographic requirements for chaos-based cryptosystems, Int. J. Bifurcation Chaos 16 (08) (2006)
2129–2151.
[4] M. Asgari-Chenaghlu, M.-R. Feizi-Derakhshi, N. Nikzad-Khasmakhi, A.-R. Feizi-Derakhshi, M. Ramezani, Z. Jahanbakhsh-Nagadeh,
T. Rahkar-Farshi, E. Zafarani-Moattar, M. Ranjbar-Khadivi, M.-A. Balafar, Cy: Chaotic yolo for user intended image encryption and
sharing in social media, Inform. Sci. 542 (2021) 212–227.
[5] A. Bochkovskiy, C.-Y. Wang, H.-Y.M. Liao, Yolov4: Optimal speed and accuracy of object detection, 2020, arXiv preprint arXiv:200
4.10934.
[6] S. Cai, L. Huang, X. Chen, X. Xiong, A symmetric plaintext-related color image encryption system based on bit permutation, Entropy
20 (4) (2018) 282.
[7] C. Cao, K. Sun, W. Liu, A novel bit-level image encryption algorithm based on 2D-LICM hyperchaotic map, Signal Process. 143
(2018) 122–133.
[8] X. Chai, An image encryption algorithm based on bit level Brownian motion and new chaotic systems, Multimedia Tools Appl. 76
(1) (2017) 1159–1175.
[9] X. Chai, Y. Chen, L. Broyde, A novel chaos-based image encryption algorithm using DNA sequence operations, Opt. Lasers Eng. 88
(Complete) (2017) 197–213.
[10] X. Chai, J. Fu, Z. Gan, Y. Lu, Y. Zhang, An image encryption scheme based on multi-objective optimization and block compressed
sensing, Nonlinear Dynam. (2022) 1–34.
[11] X. Chai, H. Wu, Z. Gan, D. Han, Y. Zhang, Y. Chen, An efficient approach for encrypting double color images into a visually
meaningful cipher image using 2D compressive sensing, Inform. Sci. 556 (2021) 305–340.
86

W. Song, C. Fu, Y. Zheng et al. Mathematics and Computers in Simulation 204 (2023) 71–88
[12] X. Chai, X. Zhi, Z. Gan, Y. Zhang, Y. Chen, J. Fu, Combining improved genetic algorithm and matrix semi-tensor product (STP) in
color image encryption, Signal Process. 183 (2021) 108041.
[13] J. Chen, L. Chen, Y. Zhou, Cryptanalysis of image ciphers with permutation-substitution network and chaos, IEEE Trans. Circuits
Syst. Video Technol. (2020).
[14] J. Chen, L. Chen, Y. Zhou, Universal chosen-ciphertext attack for a family of image encryption schemes, IEEE Trans. Multimed.
(2020).
[15] J. Chen, Z. Zhu, L. Zhang, Y. Zhang, B. Yang, Exploiting self-adaptive permutation-diffusion and DNA random encoding for secure
and efficient image encryption, Signal Process. 142 (2018) 340–353.
[16] J. Fridrich, Symmetric ciphers based on two-dimensional chaotic maps, Int. J. Bifurcation Chaos 8 (06) (1998) 1259–1284.
[17] C. Fu, Y. Zheng, M. Chen, Z.-k. Wen, A color image encryption algorithm using a new 1-D chaotic map, in: 2017 IEEE 17th
International Conference on Communication Technology (ICCT), IEEE, 2017, pp. 1768–1773.
[18] Y. Guo, Y. Luo, W. Wang, X. Luo, C. Ge, J. Kurths, M. Yuan, Y. Gao, Fixed-time synchronization of complex-valued memristive
BAM neural network and applications in image encryption and decryption, Int. J. Control Autom. Syst. 18 (2) (2020) 462–476.
[19] Z. Hua, J. Li, Y. Li, Y. Chen, Image encryption using value-differencing transformation and modified ZigZag transformation, Nonlinear
Dynam. 106 (4) (2021) 3583–3599.
[20] Z. Hua, Z. Zhu, Y. Chen, Y. Li, Color image encryption using orthogonal latin squares and a new 2D chaotic system, Nonlinear
Dynam. 104 (4) (2021) 4505–4522.
[21] R. Kaur, B. Singh, A novel approach for data hiding based on combined application of discrete cosine transform and coupled chaotic
map, Multimedia Tools Appl. 80 (10) (2021) 14665–14691.
[22] S. Mozaffari, Parallel image encryption with bitplane decomposition and genetic algorithm, Multimedia Tools Appl. 77 (19) (2018)
25799–25819.
[23] P. Murali, G. Niranjana, A.J. Paul, J.S. Muthu, Domain-flexible selective image encryption based on genetic operations and chaotic
maps, Vis. Comput. (2022) 1–23.
[24] K. Shahna, A. Mohamed, A novel image encryption scheme using both pixel level and bit level permutation with chaotic map, Appl.
Soft Comput. (2020) 106162.
[25] W. Song, C. Fu, M. Tie, C.-W. Sham, J. Liu, H.-f. Ma, A fast parallel batch image encryption algorithm using intrinsic properties of
chaos, Signal Process., Image Commun. (2022) 116628.
[26] W. Song, C. Fu, Y. Zheng, L. Cao, M. Tie, A practical medical image cryptosystem with parallel acceleration, J. Ambient Intell.
Humaniz. Comput. (2022) 1–15.
[27] W. Song, C. Fu, Y. Zheng, L. Cao, M. Tie, C.-W. Sham, Protection of image ROI using chaos-based encryption and DCNN-based
object detection, Neural Comput. Appl. 34 (7) (2022) 5743–5756.
[28] W. Song, Y. Zheng, C. Fu, P. Shan, A novel batch image encryption algorithm using parallel computing, Inform. Sci. 518 (2020)
211–224.
[29] S. Sun, A novel hyperchaotic image encryption scheme based on DNA encoding, pixel-level scrambling and bit-level scrambling, IEEE
Photonics J. 10 (2) (2018) 1–14.
[30] J. Sun, J. Han, P. Liu, Y. Wang, Memristor-based neural network circuit of pavlov associative memory with dual mode switching,
AEU-Int. J. Electron. Commun. 129 (2021) 153552.
[31] J. Sun, J. Han, Y. Wang, Memristor-based neural network circuit of memory with emotional homeostasis, IEEE Trans. Nanotechnol.
(2022).
[32] J. Sun, J. Han, Y. Wang, P. Liu, Memristor-based neural network circuit of emotion congruent memory with mental fatigue and emotion
inhibition, IEEE Trans. Biomed. Circuits Syst. 15 (3) (2021) 606–616.
[33] J. Sun, G. Han, Z. Zeng, Y. Wang, Memristor-based neural network circuit of full-function pavlov associative memory with time delay
and variable learning rate, IEEE Trans. Cybern. 50 (7) (2019) 2935–2945.
[34] J. Sun, X. Zhao, J. Fang, Y. Wang, Autonomous memristor chaotic systems of infinite chaotic attractors and circuitry realization,
Nonlinear Dynam. 94 (4) (2018) 2879–2887.
[35] L. Teng, X. Wang, A bit-level image encryption algorithm based on spatiotemporal chaotic system and self-adaptive, Opt. Commun.
285 (20) (2012) 4048–4054.
[36] L. Teng, X. Wang, J. Meng, A chaotic color image encryption using integrated bit-level permutation, Multimedia Tools Appl. 77 (6)
(2018) 6883–6896.
[37] W. Wang, J. Chen, J. Wang, J. Chen, Z. Gong, Geography-aware inductive matrix completion for personalized point-of-interest
recommendation in smart cities, IEEE Internet Things J. 7 (5) (2020) 4361–4370.
[38] W. Wang, J. Chen, J. Wang, J. Chen, J. Liu, Z. Gong, Trust-enhanced collaborative filtering for personalized point of interests
recommendation, IEEE Trans. Ind. Inf. 16 (9) (2020) 6124–6132.
[39] X. Wang, L. Feng, H. Zhao, Fast image encryption algorithm based on parallel computing system, Inform. Sci. 486 (2019) 340–358.
[40] X. Wang, S. Gao, Image encryption algorithm for synchronously updating Boolean networks based on matrix semi-tensor product
theory, Inform. Sci. 507 (2020) 16–36.
[41] Y. Wu, J.P. Noonan, S. Agaian, et al., Npcr and UACI randomness tests for image encryption, Cyber J.: Multidiscip. J. Sci. Technol.,
J. Sel. Areas Telecommun. (JSAT) 1 (2) (2011) 31–38.
[42] T. Xiang, K.-w. Wong, X. Liao, Selective image encryption using a spatiotemporal chaotic system, Chaos 17 (2) (2007) 023115.
[43] L. Xu, Z. Li, J. Li, W. Hua, A novel bit-level image encryption algorithm based on chaotic maps, Opt. Lasers Eng. 78 (2016) 17–25.
[44] M. Xu, Z. Tian, A novel image cipher based on 3D bit matrix and latin cubes, Inform. Sci. 478 (2019) 1–14.
[45] W. Zhang, W. Han, Z. Zhu, H. Yu, An ultrahigh-resolution image encryption algorithm using random super-pixel strategy, Multimedia
Tools Appl. 80 (24) (2021) 33429–33454.
87

W. Song, C. Fu, Y. Zheng et al. Mathematics and Computers in Simulation 204 (2023) 71–88
[46] Y.-Q. Zhang, X.-Y. Wang, A symmetric image encryption algorithm based on mixed linear–nonlinear coupled map lattice, Inform. Sci.
273 (2014) 329–351.
[47] W. Zhang, K.-w. Wong, H. Yu, Z.-l. Zhu, A symmetric color image encryption algorithm using the intrinsic features of bit distributions,
Commun. Nonlinear Sci. Numer. Simul. 18 (3) (2013) 584–600.
[48] W. Zhang, H. Yu, Y.L. Zhao, Z.L. Zhu, Image encryption based on three-dimensional bit matrix permutation, Signal Process. 118
(2016) 36–50.
[49] Y. Zhou, W. Cao, C.P. Chen, Image encryption using binary bitplane, Signal Process. 100 (2014) 197–207.
88