1. Introduction

The properties of chaotic maps, such as pseudo-randomness, deterministic, non-linearity, and sensitivity to initial conditions, attracted the research to use in image cryptography. There are two types of chaotic maps: (a) discrete-time iterative map system and (b) continuous time differential equation map system. The discrete-time iterative map system represents the evaluation of the system at discrete intervals of time. These types of maps are usually represented with the iterative equation. Examples of discrete maps are logistic [1] and sine maps [2]. The continuous time differential equation map is used to represent the evaluation of the system at a continuous function of time. These types of maps are described using ordinary differential equations. Lorenz system [3] and Chen system [4] are examples of differential equation maps. Both types of chaotic systems can be used in image cryptography. Discrete-time iterative map systems are usually used to generate a pseudorandom sequence, which may be used as a key for enciphering the image or shuffling the image pixels based on the generated sequences. Similarly, continuous time differential equation maps are used to produce a continuous chaotic signal, which is transformed into discrete data for the encryption of the image. In this research study, we focus on discrete-time iterative map systems because these systems require less processing and are easier to implement than continuous time differential equation maps. There are many single-dimension and multi-dimension discrete-time iterative maps proposed. Single-dimensional discrete-time iterative maps generate only a single chaotic sequence, while multi-dimensional discrete-time iterative maps generate multiple chaotic sequences simultaneously. The low-dimensional discrete-time iterative map system usually requires less processing power than the high-dimensional discrete-time iterative map system. Hence, low-dimensional systems are typically preferred in light-weight cryptosystems. The chaotic regime is another critical factor in selecting a low-dimensional discrete-time iterative map system. If the chaotic regime of a system is high, then the key space is large, and the system protects against brute force attacks. Fig 1 shows the chaotic regime of logistic and JSMP maps [5].

Download:

• PNG
  larger image
• TIFF
  original image

Fig 1.

Bifurcation diagrams of (a) JSMP Map and (b) Logistic Map.

https://doi.org/10.1371/journal.pone.0297534.g001

This diagram shows the mapping of 1000 values generated using the logistic and JSMP maps. The figure shows that both maps behave chaotically, but the logistic map’s chaotic regime is much shorter than the JSMP map. The map with the shorter chaotic regime is suspected to a brute force attack.

The applications of chaotic maps in image cryptography are diverse, spanning from Pseudo Random Number Generation (PRNG), key generation, and image transformation to confusion and diffusion. In recent research, chaotic fractional-order differential systems like the Chen system, Chua system, and memristor system have been used to generate random numbers. These systems produce multiple numerical sequences for pseudo-randomness, which are subsequently consolidated into a single-bit stream through processes involving flattening and boolean checking [6]. Additionally, the incorporation of numerous control variables in chaotic fractional-order differential systems expands the key space, adding complexity and making brute-force attacks challenging. In numerous image encryption research, chaotic maps are instrumental in generating key sequences, subsequently adjusting these sequences to the required range through module reduction. The selection of a chaotic map for key generation hinges on two crucial factors: the chaotic regime and initial parameters. A sizable chaotic regime renders brute-force attacks impractical, and the inclusion of multiple initial parameters enhances the scheme’s security since these parameters serve as secret keys. Nevertheless, securely distributing these initial parameters presents a challenging task. During the image transformation phase, a cipher image is generated by scrambling the key stream, produced through a chaotic map, and the original image. This scrambling process can take place at the bit level using operations such as xor or xnor, similar to a stream cipher. It can also operate on two bits using xor, xnor, or binary addition/subtraction operations, as seen in DNA encoding [7]. Alternatively, the process may extend to n bits, involving xor, xnor, or binary addition/subtraction, along with bit rotation operations. The fundamental requirement for the core encryption operation is reversibility. However, employing multiple operations in the encryption algorithm enhances the diffusion property, contributing to a more effective transformation. Confusion is achieved through the incorporation of substitution boxes [8]. In most of the existing image encryption approaches, a 16 × 16 S-Box is generated using a chaotic map. Given that the pixel intensity of an image falls within the range of 0 to 255, and the core encryption operation operates on eight bits (where n equals eight), the S-Box size is maintained at 16 × 16. Alternatively, some recent research studies adopt the use of multiple parallel S-Boxes with a size denoted as m for substitution operations. The majority of current image encryption schemes leverage chaotic sequences to execute nearly all the operations mentioned above, enhancing the reliability and security of the scheme [9, 10].

Many sensitive applications send image data on the Internet, such as healthcare systems, Internet of Battlefields Things (IoBTs) [11], Internet of Multimedia Things (IoMTs) [12], Industrial Automation [13], Security Surveillance [14], and many more. The privacy of image data is critical in such applications because disclosure of the information may result in financial or territorial loss. There are many applications where the privacy of image data is important, but traditional cryptographic schemes are unsuitable due to the resource-constrained environment. Hence, A novel, lightweight, and secure image encryption scheme is needed. In this research study, we

1. ➢ examine the shortcomings of existing lightweight image encryption approaches.
2. ➢ propose a secure and lightweight image encryption method utilizing a JSMP map,
3. ➢ conduct a comparative evaluation with proposed image encryption schemes using metrics like encryption/decryption times, histogram analysis, correlation analysis, entropy analysis, sensitivity analysis, and time complexity analysis.
4. ➢ conduct diverse analyses, including key space analysis and security assessment, to demonstrate the efficacy of the proposed image encryption technique in thwarting various attacks.
5. ➢ validate the proposed image encryption technique by subjecting it to NIST 800–22 test suit.

The rest of the paper is organized as follows: section 2 discusses the related work on existing image encryption schemes, section 3 contains the proposed image encryption schemes, section 4 compares the proposed image encryption scheme with existing schemes based on performance parameters, and Section 5 concludes the research.

2. Related work

In this research study, our focus is to propose a lightweight image encryption scheme using chaos cryptography. Many research articles have been published in reputed journals on image encryption using chaos cryptography, such as [15–17]. The existing image-based encryption techniques can be divided into symmetric chaos-based image encryption schemes [18–23], asymmetric chaos-based image encryption schemes [24–27], and hybrid chaos-based image encryption schemes [28, 29]. This research focuses on symmetric chaos-based image encryption, subdivided into spatial domain [30] and frequency domain [31–33]. Spatial domain image encryption schemes directly work on pixels to get the cipher image. In contrast, frequency-domain image encryption schemes transform the plain image into the frequency domain using mathematical transformation before encrypting the image. The spatial domain image encryption techniques are fast and do not distort the decrypted image. Therefore, we have selected four recently published spatial domain image encryption schemes [34–37], discussed below.

In [37], authors proposed a new robust chaotic map by combining quadratic parabolic and piecewise functions to construct a non-linear system and strong S-box. Subsequently, the authors use the newly proposed map and S-Box to propose a new image encryption scheme. A new proposed hybrid approach generates three chaotic sequences: X, Y, and Z. X is equal to M, Y is equal to N, and Z is equal to M × N, where M and N represent the rows and columns of an original image, respectively. In this proposed technique, the hash value of the original image is transformed into a value used as an initial condition to generate chaotic sequences. As the chaotic sequences are very sensitive to the initial condition, a minor change in the original image generates an entirely different chaotic sequence, X, Y, and Z. The encryption process starts by dividing the plain image P into two sub-images, PA and PB, where PA contains the higher four bits of each pixel of P and PB contains the lower four bits of each pixel of P. The value of PA is shuffled based on X and Y. The shuffled PA is further encrypted by performing the exclusive-or operation on PA, shuffled PA, and Z to get the CA. CB is generated by performing the exclusive-or operation on CA, PB, and Z. Then, the encrypted form of sub-image CA and CB are combined to get the temporary encrypted image C. To achieve confusion and diffusion, each pixel of the temporary encrypted image is shuffled based on S-Box and then added with previously shuffled pixels and Z to get the final encrypted image. The flow of the image encryption scheme is shown in Fig 2.

Download:

• PNG
  larger image
• TIFF
  original image

Fig 2. Flow of image encryption scheme of [37].

https://doi.org/10.1371/journal.pone.0297534.g002

The key sequences generated in this scheme depend on the original image’s size. If the size of the plain image increases, it takes more time to generate the sequences. Moreover, pixel segmentation, scrambling, pixel splicing, confusion, and diffusion processes during encryption make this scheme computationally intensive.

Authors in [35] proposed a lightweight image encryption scheme and 1D quadratic chaotic map to generate key sequences. Two main modules are involved in the proposed scheme: shuffling and substitution. Two sequences, x and y, of size M × 10³ and N×10³ are generated for shuffling the image. The x sequence is used to shuffle the rows of the original image, and the y sequence is used to shuffle the columns of the plain image. After shuffling the image, two more sequences, s and v, of size 8 × M × N and M × N are generated for the substitution module. The first step of the substitution module is bit transformation, which uses sequence s. Secondly, the bit transformed image is exclusive-or with v to get the final cipher image. The flow of the proposed scheme is presented in Fig 3.

Download:

• PNG
  larger image
• TIFF
  original image

Fig 3. Flow of image encryption scheme of [35].

https://doi.org/10.1371/journal.pone.0297534.g003

In the [34] proposed scheme, three chaotic sequences are generated: X1, X2, and X3 of size M+N. The sequence X1 is generated using an Improved Logistic Map (ILM), X2 is generated using the Logistic Mayan System (LOMAS), and X3 is generated using an Improved Sinusoidal Map (ISM)—the key used in this research study in an image. The key and original image are input to the encryption along with the initial conditions for the chaotic systems. The initial condition parameters are generated by taking the hash value of the original image. In the first phase of image encryption, two streams, S1 and S2, are generated by permuting original and key images based on X1 and X2, respectively. The S3 stream is generated by rotating the key image 180 and then permuting it based on X2. Then S4 is generated by taking the exclusive-or of S1, S2, and X2. S4 is permuted based on X3 to get the value of S5, and a 180-degree rotated key image is permuted based on X3 to get the stream S6. Finally, S5 and S6 streams are exclusive-or to get the final encrypted image. The flow of the scheme is shown in Fig 4.

Download:

• PNG
  larger image
• TIFF
  original image

Fig 4. Flow of image encryption scheme of [34].

https://doi.org/10.1371/journal.pone.0297534.g004

The authors of [36] proposed a new chaotic map-based random number generator module for a keystream generator. The image is transformed as a byte stream. The image stream and keystream are exclusive-or to get the final stream. The final stream is converted into a cipher image. The flow of the scheme is shown in Fig 5.

Download:

• PNG
  larger image
• TIFF
  original image

Fig 5. Flow of image encryption scheme of [36].

https://doi.org/10.1371/journal.pone.0297534.g005

The proposed technique is lightweight in terms of processing; however, it reveals the pattern in encrypted image, as shown in Fig 6.

Download:

• PNG
  larger image
• TIFF
  original image

Fig 6. Encrypted images using [36].

https://doi.org/10.1371/journal.pone.0297534.g006

The chaotic sequences used in existing schemes are presented in Table 1.

Download:

• PNG
  larger image
• TIFF
  original image

Table 1. Chaotic sequences of existing schemes.

https://doi.org/10.1371/journal.pone.0297534.t001

The existing image encryption schemes compromise privacy by disclosing the pattern in encrypted images or imposing the processing burden during encryption/decryption by generating large chaotic sequences, as shown in Table 1. In most schemes, the size of a chaotic sequence is equal to the number of pixels of a plain image. Even in some existing schemes, the recommended chaotic sequence size is more than the number of pixels of the plain image. Hence, there is a direct relationship between the size of the chaotic sequence and the number of pixels of the plain image. Such schemes are not suitable for resource-constrained environments, such as IoTs. Hence, resource-constrained computing environments need lightweight, secure image encryption schemes. In this research study, we proposed a novel lightweight and compromise-resilient image encryption scheme. The proposed scheme is compared with existing image encryption based on processing time, entropy, Mean Square Error (MSE), correlation analysis, sensitivity analysis, and Peak signal-to-noise ratio.

3. The proposed lightweight and compromise resilient image encryption scheme

The flowchart depicting the proposed image encryption scheme is presented in Fig 7. The proposed technique comprises eight distinct modules, specifically: (a) Image Splitter, (b) Key Generator, (c) Index Generator, (d) Random Number Generator, (e) Tiles Shuffler, (f) Pixels Shuffler, (g) Encryption, and (h) Decryption modules.

Download:

• PNG
  larger image
• TIFF
  original image

Fig 7. Encryption process for the proposed image encryption scheme.

https://doi.org/10.1371/journal.pone.0297534.g007

Initially, the plain image is segmented into tiles of uniform size with dimensions represented by M_t × N_t, where M_t and N_t denote the number of rows and columns in each tile. The tile height and tile width are computed by dividing the image height with M_t and image width with N_t, respectively. Subsequently, key sequences are generated utilizing the JSMP chaotic map. Mainly, three sequences are employed: X, YC, and YR, using JSMP chaotic map. The size of sequence X matches that of the tiles, M_t × N_t, and it is used for encrypting the tiles through the exclusive-or operation. The process for generating sequence X is detailed in algorithm 1. Many existing one-dimensional chaotic map generators fail to provide an extensive chaotic regime, resulting in limited key space vulnerability to brute force attacks. In the proposed scheme, keys are generated using the one-dimensional JSMP [5] chaotic map, which offers a broader chaotic regime and an enhanced key space. The key generation algorithm utilizing the JSMP chaotic map is illustrated below:

1. Algorithm 1 keyGenerator(x₀, r, S): Generating Key based on JSMP Chaotic Sequence
2. Input: initial value of x₀, control parameter r, and key size S
3. Output: Chaotic Sequence based key key ← [key₁, key₂, key₃, key_4,…….,, key_s]
4.     for i ← 1 to S
5.          
6.       
7.     endfor
8. return key

The generated value of x_i falls within the range of 0 to 1. This generated x_i value is converted into an integer and reduced by applying a modulo operation. Each key-value thus obtained falls within the range of 0 to 255, mirroring the range of image pixels. YC and YR represent index sequences sized at M_t and N_t, respectively. These sequences are generated to reorganize the pixel values within individual tiles. The process for generating YC and YR is elucidated in Algorithm 2. The index values within these sequences range from 0 to S-1. The purpose of the chaotic sequence is to reorder the index values based on the generated chaotic sequence, thereby introducing a shuffling effect.

1. Algorithm 2 indexGenerator(x₀, r, S): Creating an index for image shuffling using a JSMP Chaotic Sequence
2. Input: initial value of x₀, control parameter r, and key size S
3. Output: Chaotic Sequence based key index = [index_0, index₁, index₂, index₃, index_4,…….,, index_s-1]
4.     for i ← 0 to S-1
5.       
6.       
7.       index_i←i
8.     endfor
9.     for i ← 0 to S-1
10.       for i ← 0 to S-1
11.             if key_i > key_j, then
12.                 swap(key_i, key_j)
13.                 swap(index_i, index_j)
14.             endif
15.       endfor
16.     endfor
17. return index

The proposed scheme employs three discrete logistic map-based random number generators as logistic maps are suspected of brute force attacks due to their small chaotic regime. Therefore, it generates random numbers only to select a byte from a 256-hash value. Hence, if the attacker finds the key to generating a logistic map, he cannot decrypt the image. Each method produces a distinct sequence of numbers, even when provided with identical initial parameters. These algorithms generate random numbers ranging from 0 to 31, which are utilized to shuffle the produced hash values in the encryption process. Further information about these random number generators is provided in Algorithms 3, 4, and 5.

1. Algorithm 3 GenRanNum1(x, r,): Generating Random Number using Logistic Chaotic Sequence
2. Input: initial value of x, control parameter r
3. Output: Random number rand and updated value of x
4.     x←(r × x ×(1 − x))
5.     rand←([x] × 2¹²)mod32
6. return rand, x

The first random number generator produces a value for ’x’ within the range of 0 to 1, which is subsequently converted into an integer and then subjected to modulo operations. This algorithm derives the random value from the integral part while ignoring the fractional component. The value of x is also returned with rand to use as an input for the next call to this function.

1. Algorithm 4 GenRanNum2(x, r,): Generating Random Numbers through Logistic Chaotic Sequences
2. Input: initial value of x, control parameter r
3. Output: Random number rand and updated value of x
4.     x←(r × x × (1 − x))
5.     rand←(x × 1000000 –[x × 1000000])mod32
6. return rand, x

Algorithm 4 generates the random value based on the fractional part, and the integral part is ignored.

1. Algorithm 5 GenRanNum3(x, r,): Generating Random Number using Logistic Chaotic Sequence
2. Input: initial value of x, control parameter r
3. Output: Random number rand and updated value of x
4.     x←(r × x × (1 − x))
5.     rand←(([x] × 2¹²) + (x × 1000000 − [x × 1000000]))mod32
6. return rand, x

Similarly, Algorithm 5 generates the random value based on the fractional and the integral parts.

The image is partitioned into uniform-sized tiles, which are reorganized using the method elucidated in Algorithm 6. This algorithm generates a logistic chaotic map to produce a random sequence of indexes spanning from 0 to D-1, with ’D’ representing the total number of tiles in the original image. It’s important to note that this algorithm is specifically designed for cases where ’D’ is an odd value.

1. Algorithm 6 ShuffleTiles(tiles, D, x, r): Shuffle the tiles of original image based on index
2. Input: initial value of x, control parameter r, tiles of original image, D is count of tiles
3. Output: shuffled tiles s_tiles
4. index ← indexGenerator(x, r, D):
5.     for i ← 0 to D-1
6.       
7.     endfor
8. return s_tiles

The procedure for reversing the tile shuffling is detailed in Algorithm 7.

1. Algorithm 7 InverseShuffleTiles(stiles, D, x, r): Arrange the tiles of an image in its original form
2. Input: initial value of x, control parameter r, stiles shuffled tiles of image, D is count of tiles
3. Output: tiles in its original position
4. index = indexGenerator(x, r, D):
5.     for i ← 0 to D-1
6.       
7.     endfor
8. return tiles

Specific tile pixels are also subjected to shuffling to introduce confusion and diffusion into the encrypted image. Algorithm 8 illustrates the procedure for shuffling the pixels within a tile, wherein the shuffling is determined by the chaotic sequences YC and YR.

1. Algorithm 8 ShuffleTilePixels(tile, YC,YR, R_t, C_t): Shuffle the pixels of a tile
2. Input: tile of an image is represented with tile, YC and YR are generated using IndexGenerator() for shuffling of pixels inside tiles, and R_t and C_t represents the rows and cols of tile respectively
3. Output: shuffled tiles s_tile
4.     for i ← 0 to R_t -1
5.       for j ← 0 to C_t -1
6.            s_tile_i,j←tile_YR[i],YC[j]
7.       endfor
8.     endfor
9. return s_tile

The inverse process of pixel shuffling is shown in Algorithm 9.

1. Algorithm 9 InverseShuffleTilePixels(s_tile, YC,YR, R_t, C_t): Arrange the pixels of a tile in its original form
2. Input: shuffled tile of an image is represented with s_tile, YC and YR are generated using IndexGenerator() for shuffling of pixels inside tiles, and R_t and C_t represents the rows and cols of tile respectively
3. Output: tile in its original form tile
4. for i ← 0 to R_t -1
5.     for j ← 0 to C_t -1
6.       tile_YR[i],YC[j]←s_tile_i,j
7.     endfor
8. endfor
9. return tile

The encryption and decryption algorithm generates a hash value using SHA256, resulting in a hexadecimal representation. This hexadecimal value is then converted into an integer array comprising 32 elements, which play a crucial role in the encryption process. The conversion process for the 256-bit hexadecimal hash value is detailed in Algorithm 10.

1. Algorithm 10 GetHashValue(Image, data): generates the hash value on Image and data and convert it into an integer array of 32 elements contains the value form 0 to 255
2. Input: Image and data
3. Output: hkey is hash value of image and data in integer form
4. h = SHA256(Image+Data)
5.     for i ← 0 to len(h/2)
6.          val1← convertHextoInt(h_i)
7.          val2← convertHextoInt(h_i+1)
8.          hkey_i←(val1×16) + val2
9.     endfor
10. return hkey

The encryption algorithm takes the original image as input and transforms it into a cipher image. The process of image encryption is illustrated in Algorithm 11. To initiate the encryption process, the plain image is initially divided into D = V × V tiles, where V is an odd integer. These tiled images are then subjected to shuffling, as explained earlier. Three distinct mechanisms are incorporated to introduce randomness and enhance protection against differential attacks. Before encrypting the first tile, hkey1 is generated by applying SHA256 to the plain image. The resulting SHA256 hexadecimal value is converted into an integer array of 32 elements.

For the first cipher tile, each pixel value in the initial plain tile is exclusive-or with the chaotic sequence X and a randomly selected integer value from hkey1. The pixels in a grayscale image have a single intensity value, whereas pixels in a color image are composed of three values representing the red, green, and blue channels (RGB). When performing operations on a single pixel in a color image, the operations are applied separately to each of the RGB channels. Notably, the encryption process for odd tiles in the plain image differs. A temporary tile is created by performing exclusive-or operations on odd tiles and the previously encrypted tile. These temporary tiles are further shuffled using YC and YR to obtain shuffled temporary tiles. The shuffled temporary tiles are then exclusive-or with the chaotic sequence X and a randomly selected integer value from hkey2. The value of hkey2 is generated by applying SHA256 to the concatenation of the previously encrypted tile and hkey1. Even tiles in the original image are encrypted by performing exclusive-or operations on the even tiles, previously encrypted tiles, chaotic sequence X, and a randomly selected integer value from hkey3. hkey3 is derived by applying SHA256 to concatenate the previously encrypted tile and the chaotic sequence X.

All the encrypted tiles are combined to produce the final single cipher image.

1. Algorithm 11 EncryptImage(img, D, R_t, C_t, x, r): This algorithm converts the original image into cipher image
2. Input: img is the original image, D is the total tiles, R_t is the rows of tile, C\_t is the columns of tile, and (x, r) are the initial parameters of chaotic map

1. Output: cimg is cipher image
2. hkey1 = GetHashValue(img,””)
3. tiles←splitImage(img, D)
4. s_tiles ← ShuffleTiles(tiles, D, x, r)
5. X← keyGenerator(x, r, R_t)
6. YC← indexGenerator(x, r, C_t)
7. YR← indexGenerator(x, r+0.01, R_t)
8. k← 1
9.     for i ← 0 to R_t
10.        for j ← 0 to C_t
11.            rand, x ← GenRanNum1 (x, r)
12.            
13.            k←k+1
14.        endfor
15.     endfor
16.     for ro ← 0 to D
17.        if ro%2 = 1, then
18.       temp_tile←empty tile of size R_t × C_t
19.         for i← 0 to R_t
20.           for j← 0 to C_t
21.             
22.           endfor
23.         endfor
24.       shuffle_temp_tile← ShuffleTilePixels(temp_tile,YC,YR, R_t, C_t)
25.       hkey2← GetHashValue(tiles[ro-1],hkey1)
26.       k← 0
27.         for i ← 0 to R_t
28.            for j ← 0 to C_t
29.                rand, x← GenRanNum2(x,r)
30.                
31.                k←k+1
32.            endfor
33.          endfor
34.       e_tile[ro]← temp_tile
35.     else if ro%2 = 0, then
36.       k ← 0
37.       hkey3← GetHashValue (e_tiles[ro-1]), X)
38.        for i ← 0 to R_t
39.          for j ← 0 to C_t
40.            rand, x← GenRanNum2 (x,r)
41.            
42.            k←k+1
43.         endfor
44.        endfor
45.       e_tiles[ro]← temp_tile
46.     endif
47.     endfor
48. c_img← CombineImage(etiles, D)
49. return c_img

The decryption algorithm accepts a cipher image as its input and transforms it into a plain image. During the conversion process, the decryption algorithm requires the cipher image, hkey1 value, the value of D, and the initial condition (x, r) for the chaotic sequence. The remaining secret values of X, YR, and YC are generated using the method detailed in the encryption algorithm. The encrypted image is partitioned into D = V×V encrypted tiles. The initial encrypted tile undergoes a transformation into a plain tile through an exclusive_or operation involving the first encrypted tile, a generated key sequence X, and hkey1. For the decryption of odd tiles, a temporary tile is formed by exclusively ORing the current odd tile with the previously decrypted tile. Subsequently, an inverse shuffling operation is applied to the temporary tile using chaotic sequences YC and YR to counteract the effects of shuffling during encryption. Following this, the shuffled temporary tile is exclusively ORed with chaotic sequence X and a randomly generated hkey2 to obtain the plain tile. Conversely, even tiles of the encrypted image are transformed into plain tiles by performing an exclusive_or operation on the current encrypted tile, the previously encrypted tile, chaotic sequence X, and a randomly generated hkey3. Finally, all decrypted tiles are reshuffled and combined to reconstruct the original file. The decryption process inverses the encryption process and is explained in Algorithm 12.

1. Algorithm 12 DecryptImage(c_img, hkey1, D, R_t, C_t, x, r): This algorithm coverts the cipher image into original image
2. Input: c_img is the cipher image, hkey1 is the hash value of original, D is the total tiles, R_t is the total rows of tile, C_t is the total columns of tile, and (x, r) are the initial parameters of chaotic map
3. Output: img is plain image
4. e_tiles← SplitImage(c_img, D)
5. X← keyGenerator(x, r, R_t)
6. YC← indexGenerator(x, r, C_t)
7. YR← indexGenerator(x, r+0.01, R_t)
8. k← 1
9.     for i ← 0 to R_t
10.      for j ← 0 to C_t
11.        rand, x ← GenRanNum1 (x, r)
12.        
13.        k←k+1
14.      endfor
15.     endfor
16.     for ro ← 1 to D
17.      if ro%2 = 1, then
18.        temp_tile←empty tile of size R_t × C_t
19.         for i← 0 to R_t
20.     for j← 0 to C_t
21.            
22.         endfor
23.        endfor
24.        hkey2 ← GetHashValue(tiles[ro-1],hkey1)
25.        k← 0
26.       for i ← 0 to R_t
27.        for j ← 0 to C_t
28.          rand,x ← GenRanNum2(x,r)
29.          
30.          k←k+1
31.        endfor
32.     endfor
33.       temp_tile← InverseShuffleTilePixels(temp_tiles, YC, YR, R_t, C_t)
34.     for i← 0 to R_t
35.      for j ← to C_t
36.       
37.      endfor
38.     endfor
39.     tiles[ro] ← temp_tile
40.    else if ro%2 = 0, then
41.     k ← 0
42.     hkey3← GetHashValue (e_tiles[ro-1]), X)
43.     for i ← 0 to R_t
44.      for j ← 0 to C_t
45.       rand,x← GenRanNum2 (x,r)
46. 
47.       k←k+1
48.      endfor
49.     endfor
50.     tiles[ro]← temp_tile
51.    endif
52.   endfor
53. img = combineImage(tile, D)
54. return img

4. Experimental setup

We used Python to implement all the image encryption schemes and evaluated them on the same system having specification Intel(R) Core (TM) i7-10870H CPU @ 2.20 GHz 2.21 GHz with 16GB RAM. We have used 8 RGB images of different sizes from CVG-UGR (https://ccia.ugr.es/cvg/dbimagenes/) and USC-SIPI (https://sipi.usc.edu/database/) image databases. The details of the images used in the experiment are shown in Table 2.

Download:

• PNG
  larger image
• TIFF
  original image

Table 2. Image dataset used for experiments.

https://doi.org/10.1371/journal.pone.0297534.t002

We have used the JSMP map to generate a chaotic sequence because of its large chaotic regime—the value of r∈[0.502,2000]. The initial condition used for the chaotic map is x_o = 0.4544 and r = 3.91122. The schemes are evaluated based on encryption/decryption time, entropy, Mean Square Error (MSE), correlation analysis, sensitivity analysis, and Peak Signal to noise ratio. The encryption results of various test images with tile sizes seven by seven are shown in Fig 8.

Download:

• PNG
  larger image
• TIFF
  original image

Fig 8. The plain images and their encrypted images using the proposed technique with tile size seven by seven.

https://doi.org/10.1371/journal.pone.0297534.g008

4.1 Encryption/decryption time

This is the time taken by the encryption and decryption process in milliseconds. This time also depends on the system load at the time of evaluation. To overcome this issue, we have taken reading multiple times, and the average result is presented in Figs 9 and 10. The technique presented in [36] takes less time than others in encrypting and decrypting the image. The main reason is that the operations involved in [36] are lightweight. However, this scheme reveals the pattern in the encrypted image. Hence, it’s not secure to use. The scheme presented in [37] takes more time than others because of the operations, such as chaotic sequence generation, pixel transformation, shuffling of the pixels, exclusive-or, binary addition, and SBox operation.

Download:

• PNG
  larger image
• TIFF
  original image

Fig 9. Encryption time in milliseconds.

https://doi.org/10.1371/journal.pone.0297534.g009

Download:

• PNG
  larger image
• TIFF
  original image

Fig 10. Decryption time in milliseconds.

https://doi.org/10.1371/journal.pone.0297534.g010

The performance of the proposed scheme is better than the existing schemes [34, 35, 37] because the proposed scheme splits the image into multiple tiles of the same size. The size of the chaotic sequence generated by the proposed scheme is equal to the size of the pixels of a tile. The existing scheme [34, 35, 37] generates a chaotic sequence equal to the size of pixels in the plain image. The pixel in a tile is much less than the pixels in the original image. This is the main reason our scheme performs better than the existing one. As there are multiple readings of the proposed scheme with different tile distributions, The optimal performance of the proposed scheme is observed when we divide the image at seven by seven.

The decryption times show the same behaviours exhibited in the encryption process.

4.2 Histogram analysis

The analysis of histograms offers valuable insights into the distribution patterns of pixel intensities inside images. A significant image generally exhibits a non-uniform distribution of pixel intensities throughout its entirety, whereas an encrypted image displays a uniform distribution. A good image encryption technique achieves a uniform distribution of pixels throughout the image. Fig 11 depicts the histogram of two images, namely the baboon and car, alongside their respective encrypted counterparts, which have been processed using the proposed image encryption technique. The analysis reveals that the distribution of images exhibits non-uniform characteristics, but the distribution of the encrypted image demonstrates uniform or flat attributes. Therefore, the technique under consideration aims to achieve a uniform distribution of RGB pixels throughout the image.

Download:

• PNG
  larger image
• TIFF
  original image

Fig 11.

Analysis of histograms for two plaintext images encrypted using a proposed image encryption technique: (a) Original baboon image, (b) Histogram of the original baboon image, (c) Encrypted baboon image, (d) Histogram of the encrypted baboon image, (e) Original car image, (f) Histogram of the original car image, (g) Encrypted car image, and (h) Histogram of the encrypted car image.

https://doi.org/10.1371/journal.pone.0297534.g011

4.3 Correlation analysis

The correlation coefficient quantifies the degree of association between neighbouring pixels in an image. A higher correlation coefficient value indicates a significant association between the adjacent pixels of an image. If the correlation coefficient value is lower for an image, it indicates a weak or non-existent association between the neighbouring pixels of the image. If the image encryption technique fails to disrupt the correlation existing between neighbouring pixels within the encrypted image, an adversary may exploit this vulnerability through the utilization of a correlation attack, thereby obtaining valuable information. The calculation of the correlation coefficient value is determined by employing the subsequent formula: (1) (2) (3) (4)

The formulas are utilized to calculate the correlation between consecutive columns of an image. In this context, "p_i" denotes the i^th pixel column, "p_i+1" denotes the (i+1)^th pixel column, and "N" indicates the total number of pixels in a column. Fig 12 depicts the correlation between two consecutive columns and adjacent rows before and after the encryption process of two images utilizing the proposed image encryption technique. The results indicate that the suggested image encryption technique disrupts the correlation between horizontally and vertically neighbouring pixels within an encrypted image.

Download:

• PNG
  larger image
• TIFF
  original image

Fig 12.

The relationship between adjacent rows and adjacent columns of plain image and encrypted image (a) plain image of baboon, (b) relationship between two adjacent columns of plain image baboon, (c) relationship between two adjacent rows of plain image baboon (d) encrypted image of baboon, (e) relationship between two adjacent columns of encrypted image baboon, (f) relationship between two adjacent rows of encrypted image baboon, (g) plain image of car, (h) relationship between two adjacent columns of plain image car, (i) relationship between two adjacent rows of plain image car (j) encrypted image of car, (k) relationship between two adjacent columns of encrypted image car, (l) relationship between two adjacent rows of encrypted image car.

https://doi.org/10.1371/journal.pone.0297534.g012

The proposed scheme is also compared with existing image encryption schemes. The obtained results are shown in Table 3.

Download:

• PNG
  larger image
• TIFF
  original image

Table 3. Correlation coefficient comparison.

https://doi.org/10.1371/journal.pone.0297534.t003

The result shows a minor difference in each scheme’s average correlation coefficient value. The value of the correlation coefficient of [35] is better than our proposed scheme, with a minor difference. Alternatively, the correlation coefficient value of the proposed technique is better than [34, 36, 37]. The result also shows that our proposed scheme performs best with the tile size nine by nine. However, the performance of the proposed scheme is also acceptable with the tile size seven by seven.

4.4 Entropy analysis

Entropy measures the randomness or uncertainty of an image. A higher entropy value shows more randomness, making it difficult to get the information source. The calculated entropy value of the proposed technique and comparison with existing techniques is presented in Table 4.

Download:

• PNG
  larger image
• TIFF
  original image

Table 4. Entropy analysis.

https://doi.org/10.1371/journal.pone.0297534.t004

The result shows that all the schemes introduce some randomness in encrypted images. The entropy of the proposed scheme with tile seven by seven is almost equal to [37] and is better than [34–36].

4.5 Mean Square Error (MSE) analysis

Mean Square Error (MSE) measures the difference between plain and encrypted images. The MSE value is calculated using the following formula: (5)

Where P represents the plain image, E represents the encrypted image, and M and N are the image dimensions. The cryptosystem is considered strong if the MSE difference is high between the original and encrypted images. The MSE value of the proposed scheme and the existing scheme is presented in Table 5.

Download:

• PNG
  larger image
• TIFF
  original image

Table 5. MSE analysis.

https://doi.org/10.1371/journal.pone.0297534.t005

The result shows that the MSE value of the proposed technique increases with the tile size. The MSE value of the proposed scheme with tile size nine by nine and greater produces better results than existing schemes.

4.6 Sensitivity analysis

The secure image encryption schemes must support the avalanche effect. The cipher should be changed completely if there is a minor change in the plain image. The sensitivity analysis evaluates the Number of Changing Pixel Rate (NPRC) and Unified Averaged Changed Intensity (UACI). The ideal values of NPRC are greater than 99, and UACI is greater than 33 for a secure image encryption scheme. NPRC and UACI values are computed using the following formulas: (6)

To evaluate the value of UACI, two identical images having only a one-pixel difference are encrypted, and the cipher images are represented with C1 and C2.

(7)(8)

While testing this scheme in our experimental setup, the key’s value remains the same for both encrypted images with a one-pixel difference. The obtained results are presented in Tables 6 and 7.

Download:

• PNG
  larger image
• TIFF
  original image

Table 6. UACI analysis.

https://doi.org/10.1371/journal.pone.0297534.t006

Download:

• PNG
  larger image
• TIFF
  original image

Table 7. NPRC analysis.

https://doi.org/10.1371/journal.pone.0297534.t007

It is observed from the result that the proposed scheme is secure against differential attack as the value of both parameters is in the acceptable range in most of the cases. The result of the schemes presented in [35, 36] is nearly equal to zero, and the result of [34] is also not in an acceptable range. The only existing scheme that protects against differential attack is [37]. The performance of our proposed technique is better than [37], with a tile size seven by seven.

4.7. NIST 800–22 test suits

We have tested our proposed image encryption scheme using NIST 800–22 test suits to validate the randomness in the encrypted image of a baboon of size 512 by 512. For each NIST 800–22 test, a P-value exceeding 0.01 is required for successful passage. The outcomes presented in Table 8 affirm that the encrypted image successfully passed all the randomness tests outlined in NIST 800–22.

Download:

• PNG
  larger image
• TIFF
  original image

Table 8. The validation of the proposed encryption scheme based on NIST 800–22 test suits.

https://doi.org/10.1371/journal.pone.0297534.t008

4.8. Contrast analysis

This analysis provides information on the difference in intensity of the darkest and brightest parts of an image. A greater contrast value indicates a more significant difference, while a lower value signifies a more even distribution of tones. When the image encryption algorithm relies on pixel values or frequency components, a cryptic image with an elevated contrast value becomes challenging for an attacker to decipher. Table 9 presents the contrast value of the original image and encrypted image using the proposed image technique. The results confirm that the proposed image encryption substantially enhances the contrast level in the encrypted image.

Download:

• PNG
  larger image
• TIFF
  original image

Table 9. Contrast analysis of the proposed image encryption scheme.

https://doi.org/10.1371/journal.pone.0297534.t009

4.11. Time complexity

The key operations within the proposed image encryption method encompass image splitting, tile shuffling, key generation, encryption, decryption, inverse splitting, and tile combination. The time complexity associated with both the image splitting and tile combination processes is O(T), where T signifies the total number of tiles. Likewise, the shuffle and reshuffle operations exhibit a time complexity of O(T). The encryption and decryption algorithms contribute a time complexity of O(D × D × T), where D denotes the number of rows or columns in a tile, and T represents the total number of tiles. The time complexity of the key generation module is O(D × D). Consequently, the comprehensive complexity of the proposed image encryption method is expressed as O(D × D × T). Table 10 illustrates a comparison of time complexities between the proposed image encryption technique and existing image encryption techniques. The analysis affirms that the time complexity of the proposed image encryption outperforms that of the existing image encryption schemes.

Download:

• PNG
  larger image
• TIFF
  original image

Table 10. Time complexities comparison.

https://doi.org/10.1371/journal.pone.0297534.t010

5. Conclusion

Image data is among the most important data being shared on the Internet. Many sensitive applications, such as Healthcare, Internet of Battlefield Things (IoBTs), Satellite, Surveillance applications, and many more, send image data over the Internet. The image data of such applications must be secured to avoid any physical or financial loss. The resource limitation of a few of the applications described above restricts the usage of traditional techniques for image encryption. Hence, there is a need for a lightweight and secure image encryption scheme. The object of this research study is to propose a lightweight and secure image encryption technique for resource-constrained environments. The result shows that the proposed image encryption scheme with the seven-by-seven tiles gives optimal results compared to the existing lightweight image encryption schemes. Moreover, the security analysis also indicates that the proposed scheme is secure against differential attacks. The brute force attack is also impossible because of the long chaotic regime of the JSMP map and the 256-bit key used as the encryption key.

The proposed image encryption scheme functions seamlessly with images that can be perfectly divided into equal-sized tiles. In cases where an image possesses dimensions that do not permit division into tiles of equal size, the algorithm refrains from encrypting less than 0.5% of the final rows and columns. Nonetheless, this impact remains imperceptible to the human eye. Our objective is to rectify and eliminate this limitation in future iterations.