Chaos-based parallel digital image encryption algorithm

Abstract

The invention discloses a parallel digital image encryption algorithm based on chaos, and relates to the technical field of image encryption, and the encryption algorithm comprises the following steps: S1, according to a file header definition, reading image height, width and data offset information by using a BITMAPINFOHEADER structural body, and opening up memory spaces required by R, G and B3 color components according to the information; s2, concurrently generating scrambling coordinates through three threads, and realizing pixel scrambling in R, G and B color spaces; and S3, according to the scrambling coordinates generated by the three threads, completing scrambling operation, namely, exchanging each pixel point in R, G and B with a pixel point specified by (x, y, color comp). According to the encryption algorithm provided by the invention, the calculation efficiency is improved by introducing a bidirectional diffusion mechanism based on the parallel architecture design; according to the image encryption system provided by the invention, the key length is 248 bits, and the security problem encountered by most of the existing chaotic image encryption systems can be well solved.

Description

Technical Field

[0001] The present invention relates to the technical field of image encryption, and in particular to a chaos-based parallel digital image encryption algorithm. Background Art

[0002] More than 70% of the information received by humans comes from vision, or image information, including images, graphics, videos, and texts. Image information is vivid and vivid, and is one of the important means of expressing information that is widely used and indispensable by humans. In today's information age, the rise and popularization of the Internet has made the exchange of information more convenient and faster. At the same time, traditional encryption methods cannot be fully and effectively used for multimedia information with large data volumes and real-time transmission. In the past decade, domestic and foreign scholars have made a lot of achievements in the research of chaotic image encryption technology, but there are still some shortcomings, which are mainly manifested in the following two points: 1. Most of the existing results use low-dimensional chaotic systems in the diffusion stage, which have the advantages of simple structure and fast speed, but their disadvantages of small key space and low security are also very prominent; 2. Although the chaotic encryption algorithm has significant advantages over the classical grouping algorithm in encryption speed, for the current application of more and more high-resolution images, the chaotic algorithm will still introduce non-negligible delays and cannot fully meet the real-time transmission requirements of large-capacity images in broadband network environments. In this regard, we propose a parallel digital image encryption algorithm based on chaos. Summary of the invention

[0003] In order to solve the above technical problems, a chaos-based parallel digital image encryption algorithm is provided. This technical solution solves the above problems.

[0004] To achieve the above objectives, the technical solution adopted by the present invention is: a parallel digital image encryption algorithm based on chaos, the encryption algorithm steps are:

[0005] S1. According to the file header definition, use the BITMAPINFOHEADER structure to read the image height, width and data offset information, and open up the memory space required for the three color components R, G, and B according to the information;

[0006] S2, generate scrambled coordinates through three threads concurrently to achieve pixel scrambling in the R, G, and B color spaces;

[0007] S3. Complete the scrambling operation according to the scrambled coordinates generated by the three threads, that is, exchange each pixel in R, G, and B with the pixel specified by (x, y, color_comp);

[0008] S4, performing diffusion operation on the scrambled R, G, and B components, changing the value of the pixel and diffusing the influence of each pixel to the entire ciphertext image;

[0009] S5, write the encrypted R, G, B memory data into the file to complete the encryption operation;

[0010] The algorithm system architecture is a parallel scrambling algorithm and diffusion stage architecture.

[0011] Preferably, the encryption algorithm architecture steps separate the R, G, and B components of the image before encrypting it to obtain data corresponding to the three primary colors. The scrambling adopts a pixel exchange mechanism, and three threads concurrently iterate the chaotic system to generate pseudo-random coordinates that identify the pixel position. In the diffusion stage, three threads are also used to iterate the chaotic system, and key streams acting on the three color components R, G, and B are concurrently generated to complete the encryption operation of the R, G, and B components.

[0012] Preferably, the image scrambling algorithm is implemented based on a pixel exchange mechanism. Each pixel in the R, G, and B color spaces is exchanged with a certain pixel in turn. The exchange object is selected in a pseudo-random manner. Pseudo-random coordinates are generated based on logistic chaotic mapping. Three concurrent threads respectively generate the x-coordinate, y-coordinate and color channel that determine the pixel position.

[0013] Preferably, the mathematical expression of the logistic chaotic map is:

[0014] x n+1 =μx n (1-x n ),x n ∈[0,1],∈￥,μ∈[0,4]

[0015] where x n+1 Expressed as the proportion of the next generation population, x n is the number of the nth generation population, and μ is a positive real number.

[0016] Preferably, the diffusion stage generates a key stream based on the Lorenz system. The key streams generated by the three threads are used for bidirectional diffusion operations of the three color channels R, G, and B respectively. The mathematical expression of the Lorenz system is:

[0017]

[0018] Among them, x, y, z are state variables, t represents time, σ, ρ, β are system parameters, and when σ=10, ρ=28, β=8 / 3, the system is in a chaotic state;

[0019] When solving the Lorenz system, the 4th-order Runge-Kutta method is used, and the specific solution formula is:

[0020]

[0021] in

[0022]

[0023] h is the step length;

[0024] A bidirectional diffusion mechanism is used to improve the speed of the encryption system. The diffusion process consists of two independent diffusion stages with different directions. In the first stage of the bidirectional diffusion process, similar to the traditional diffusion method, the value of each pixel is changed in order from left to right and from top to bottom. A small change at a certain point (M′, N′) will diffuse to all subsequent points of the point. In the second stage of diffusion, the value of each pixel is changed in order from bottom to top and from right to left. This small difference in the plaintext image is diffused to the entire ciphertext image through multiple difference points obtained in the first stage.

[0025] Preferably, the specific step of implementing pixel scrambling in the R, G, B color space in step S2 is implemented by creating three threads and calling the following function three times, and the function form is:

[0026] hHandle[iThrd]=(HANDLE)_beginthreadex(NULL,0,ThreadWorkerEn_permutation_key,&threadArg[iThrd],CREATE_SUSPENDED,NULL)

[0027] Among them, ThreadWorkerEn_permutation_key is the thread task function;

[0028] Since the execution order of threads is not controlled by the user, a thread number is assigned to each thread to complete a fixed task. The thread number is defined in the custom thread parameter structure threadArg, and the logistic initial values ​​of the three threads are generated by the chaotic map iteration;

[0029] Set the priority of the three threads by calling the system function SetThreadPriority(HANDLE,int).

[0030] Preferably, set the affinity of the three threads by calling the system function

[0031] SetThreadAffinityMask(HANDLE,DWORD) implementation;

[0032] Since the thread is in a suspended state when it is created, call the system function ResumeThread(Handle) to resume the execution of the thread and start the scrambling operation;

[0033] The thread task function needs to iterate the logistic map 3*W*H times to generate scrambled coordinates for the R, G, and B components, where W is the width of the image and H is the height of the image. The quantization method of the pseudo-random coordinates is as follows:

[0034]

[0035] Among them, key_x, key_y, key_color_comp are the current values ​​of the logistic mapping state variables, x-coor, y-coor, and color-comp represent the row, column, and color channel of the exchange object respectively;

[0036] Call the system function WaitForMultipleObjects(DWORD,constHandle*,BOOL,DWORD) to wait for the completion of three threads;

[0037] Call the system function CloseHandle(HANDLE) to end the three threads.

[0038] Preferably, the diffusion operation step in step S4 is specifically performed by reopening the thread and specifying the thread task as the diffusion function ThreadWorkerEn(void*);

[0039] Assign initial values ​​to the Lorenz systems in the three threads through KeyGeneratorForEachThread_diffusion(ThreadArg*). Similar to the scrambling process, threads 0, 1, and 2 complete the diffusion operations of the three color channels R, G, and B respectively; set the priorities of the three threads by calling the system function SetThreadPriority(HANDLE, int); set the affinity of the three threads by calling the system function SetThreadAffinityMask(HANDLEDWORD); call the system function ResumeThread(Handle) to resume the execution of the threads; the three thread task functions use the Runge-Kutta method to solve the Lorenz system. According to the current values ​​of the three state variables of the Lorenz system, the following quantization method is used to obtain the three key stream elements, and the quantization form is:

[0040]

[0041] The Lorenz system is solved by using the Runge-Kutta method.

[0042] Preferably, the generated key stream elements are used to perform encryption operations on the pixels, and the encryption formula is:

[0043]

[0044] where c3× (n-1)+1 is the ciphertext pixel value, k xn is the quantized key stream element value, p3× (n-1)+1 is the plaintext pixel value.

[0045] Preferably, the diffusion process is a two-round operation, the first round of diffusion direction is from left to right, and the second round is from bottom to top. This diffusion method is superior to other similar diffusion methods in terms of efficiency;

[0046] Call the system function WaitForMultipleObjects(DWORD,constHandle*,BOOL,DWORD) to wait for the end of the three threads; call the system function CloseHandle(HANDLE) to end the three threads and complete the diffusion operation.

[0047] Compared with the prior art, the present invention has the following beneficial effects:

[0048] The encryption algorithm proposed in the present invention is based on a parallel architecture design. Three threads are used in the scrambling and diffusion stages to realize the parallel generation of scrambled coordinates and diffusion key streams, respectively, which makes full use of the multi-core resources of the CPU and significantly improves the efficiency of the encryption system. By introducing a scrambling strategy based on pixel exchange, the problems of periodicity, fixed points and image shape restrictions existing in the existing chaotic scrambling methods are solved. By introducing a bidirectional diffusion mechanism, the number of diffusion rounds required for secure encryption is effectively reduced, and the calculation efficiency is improved. The proposed image encryption system has a key length of 248 bits, which can well solve the security problems encountered by most existing chaotic image encryption systems. BRIEF DESCRIPTION OF THE DRAWINGS

[0049] Figure 1 This is the overall design diagram of the encryption algorithm of the present invention;

[0050] Figure 2 This is a schematic diagram of the bidirectional diffusion method proposed by the present invention;

[0051] Figure 3 is a pixel distribution histogram of a plaintext image of the present invention;

[0052] Figure 4 This is the pixel distribution histogram analysis of the ciphertext image of the present invention. DETAILED DESCRIPTION

[0053] The following description is used to disclose the present invention so that those skilled in the art can implement the present invention. The preferred embodiments described below are only examples, and those skilled in the art may think of other obvious variations.

[0054] A parallel digital image encryption algorithm based on chaos. The encryption algorithm steps are:

[0055] S1. According to the file header definition, use the BITMAPINFOHEADER structure to read the image height, width and data offset information, and open up the memory space required for the three color components R, G, and B according to the information;

[0056] S2, generate scrambled coordinates through three threads concurrently to achieve pixel scrambling in the R, G, and B color spaces;

[0057] S3. Complete the scrambling operation according to the scrambled coordinates generated by the three threads, that is, exchange each pixel in R, G, and B with the pixel specified by (x, y, color_comp);

[0058] S4, performing diffusion operation on the scrambled R, G, and B components, changing the value of the pixel and diffusing the influence of each pixel to the entire ciphertext image;

[0059] S5, write the encrypted R, G, B memory data into the file to complete the encryption operation;

[0060] The algorithm system architecture is a parallel scrambling algorithm and diffusion stage architecture.

[0061] The encryption algorithm architecture steps are as follows: before encrypting the image, its R, G, and B components are separated to obtain data corresponding to the three primary colors. The scrambling adopts a pixel exchange mechanism. Three threads concurrently iterate the chaotic system to generate pseudo-random coordinates that identify the pixel position. In the diffusion stage, three threads are also used to iterate the chaotic system, and key streams acting on the three color components R, G, and B are concurrently generated to complete the encryption operation of the R, G, and B components.

[0062] The specific steps of implementing pixel scrambling in the R, G, and B color spaces in step S2 are to create three threads and call the following function three times. The function form is:

[0063] hHandle[iThrd]=(HANDLE)_beginthreadex(NULL,0,ThreadWorkerEn_permutation_key,&threadArg[iThrd],CREATE_SUSPENDED,NULL)

[0064] Among them, ThreadWorkerEn_permutation_key is the thread task function;

[0065] Since the execution order of threads is not controlled by the user, a thread number is assigned to each thread to complete a fixed task. The thread number is defined in the custom thread parameter structure threadArg, and the logistic initial values ​​of the three threads are generated by the chaotic map iteration;

[0066] Set the priority of the three threads by calling the system function SetThreadPriority(HANDLE,int);

[0067] Set the affinity of the three threads by calling the system function

[0068] SetThreadAffinityMask(HANDLE,DWORD) implementation;

[0069] Since the thread is in a suspended state when it is created, call the system function ResumeThread(Handle) to resume the execution of the thread and start the scrambling operation;

[0070] The thread task function needs to iterate the logistic map 3*W*H times to generate scrambled coordinates for the R, G, and B components, where W is the width of the image and H is the height of the image. The quantization method of the pseudo-random coordinates is as follows:

[0071]

[0072] Among them, key_x, key_y, key_color_comp are the current values ​​of the logistic mapping state variables, x-coor, y-coor, and color-comp represent the row, column, and color channel of the exchange object respectively;

[0073] Call the system function WaitForMultipleObjects(DWORD,constHandle*,BOOL,DWORD) to wait for the completion of three threads;

[0074] Call the system function CloseHandle(HANDLE) to end the three threads.

[0075] The diffusion operation step in step S4 specifically restarts the thread and specifies the thread task as the diffusion function ThreadWorkerEn(void*);

[0076] Assign initial values ​​to the Lorenz systems in the three threads through KeyGeneratorForEachThread_diffusion(ThreadArg*). Similar to the scrambling process, threads 0, 1, and 2 complete the diffusion operations of the three color channels R, G, and B respectively.

[0077] Set the priority of the three threads by calling the system function SetThreadPriority(HANDLE,int); set the affinity of the three threads by calling the system function SetThreadAffinityMask(HANDLEDWORD);

[0078] Call the system function ResumeThread(Handle) to resume the execution of the thread;

[0079] The three thread task functions use the Runge-Kutta method to solve the Lorenz system. According to the current values ​​of the three state variables of the Lorenz system, the following quantization method is used to obtain the three key stream elements. The quantization form is:

[0080]

[0081] The Lorenz system is solved by using the Runge-Kutta method;

[0082] Use the generated key stream elements to encrypt the pixels. The encryption formula is:

[0083]

[0084] where c3× (n-1)+1 is the ciphertext pixel value, k xn is the quantized key stream element value, p3× (n-1)+1 is the plaintext pixel value;

[0085] The diffusion process is a two-round operation. The first round of diffusion is from left to right, and the second round is from bottom to top. This diffusion method is more efficient than other similar diffusion methods.

[0086] Call the system function WaitForMultipleObjects(DWORD,constHandle*,BOOL,DWORD) to wait for the end of the three threads; call the system function CloseHandle(HANDLE) to end the three threads and complete the diffusion operation.

[0087] Key space analysis

[0088] The key space refers to the total amount of different keys that can be used in the encryption or decryption process. For a secure encryption system, the key space should be large enough to make exhaustive attacks ineffective. The key of the encryption system built based on this scheme consists of two parts: the scrambling key Key-P and the diffusion key Key-D;

[0089] In the scrambling stage, the logistic chaotic map is used to generate pseudo-random coordinates, and the initial value x0 of the state variable of the logistic map is used as the scrambling key;

[0090] The diffusion key Key-D is composed of the initial values ​​of the three state variables of the Lorenz system (x0, y0, z 0) Composition,In this experiment, the above four variables are all stored in 64-bit double-precision floating-point numbers. According to the IEEE floating-point number standard, the effective precision of this data type is 15 bits;

[0091] The scrambling key and the diffusion key are independent of each other, so the total key space Key-S satisfies

[0092] Key-S = key-P × key-D = (10 15 ) 4 ≈2 198

[0093] Table 1 Comparison of key spaces between this application and three classic symmetric encryption algorithms

[0094]

[0095] Table 1

[0096] Statistical attack analysis

[0097] Based on the visual redundancy of images, statistical analysis has become the most common and effective method to attack image encryption systems. Through histogram analysis, adjacent pixel correlation analysis and information entropy analysis, it is proved that the image encryption system implemented in this application can effectively resist various common statistical attack methods.

[0098] Histogram analysis

[0099] The histogram intuitively describes the frequency distribution of pixel values ​​of an image. For a well-designed image encryption system, the frequency of pixel values ​​of the ciphertext image output should obey a uniform distribution to hide the redundancy in the plaintext information and prevent the attacker from observing any information about the association between the plaintext and the ciphertext. The color image is composed of the superposition of images of three color channels, so the distribution of pixels of different color channels is statistically analyzed separately. Figure 3 As shown, (a) is the Lena plaintext image, (b)-(d) are the R, G, and B components of (a), and (e)-(g) are the histograms of the R, G, and B components, respectively. Figure 4 As shown, (a) is the ciphertext image of the Lena plaintext image, (b)-(d) are the R, G, and B components of (a), and (e)-(g) are the histograms of the R, G, and B components, respectively.

[0100] The purpose of this paper is to apply chaos to image encryption, and to improve the common shortcomings of existing chaotic algorithms, such as periodicity, image graphic restrictions, fixed points, and key stream and key correlation. Based on the "scrambling-diffusion" architecture of traditional chaotic image encryption algorithms, a hyperchaotic system is introduced, and a digital image encryption system based on hyperchaos is proposed. The scrambling function is implemented based on a pixel exchange mechanism, and the diffusion function is implemented based on a hyperchaotic system. In the process of using the diffused key stream, the plaintext pixel value is dynamically selected to make the key stream correlated with the plaintext, thereby enhancing the ability to resist known / chosen plaintext attacks.

[0101] The above shows and describes the basic principles, main features and advantages of the present invention. Those skilled in the art should understand that the present invention is not limited to the above embodiments. The above embodiments and descriptions only describe the principles of the present invention. The present invention may be subject to various changes and improvements without departing from the spirit and scope of the present invention. These changes and improvements fall within the scope of the present invention. The scope of protection claimed by the present invention is defined by the attached claims and their equivalents.

Claims

1. A chaos-based parallel digital image encryption algorithm, characterized in that: The encryption algorithm steps are: S1. According to the file header definition, use the BITMAPINFOHEADER structure to read the image height, width and data offset information, and open up the memory space required for the three color components R, G, and B according to the information; S2, generate scrambled coordinates through three threads concurrently to achieve pixel scrambling in the R, G, and B color spaces; S3. Complete the scrambling operation according to the scrambled coordinates generated by the three threads, that is, exchange each pixel in R, G, and B with the pixel specified by (x, y, color_comp); S4, performing diffusion operation on the scrambled R, G, and B components, changing the value of the pixel and diffusing the influence of each pixel to the entire ciphertext image; S5, write the encrypted R, G, B memory data into the file to complete the encryption operation; The algorithm system architecture is a parallel scrambling algorithm and diffusion stage architecture.

2. According to claim 1, a chaos-based parallel digital image encryption algorithm is characterized in that: The encryption algorithm architecture steps are as follows: before encrypting the image, its R, G, and B components are separated to obtain data corresponding to the three primary colors. The scrambling adopts a pixel exchange mechanism. Three threads concurrently iterate the chaotic system to generate pseudo-random coordinates that identify the pixel position. In the diffusion stage, three threads are also used to iterate the chaotic system, and key streams acting on the three color components R, G, and B are concurrently generated to complete the encryption operation of the R, G, and B components.

3. According to claim 1, a chaos-based parallel digital image encryption algorithm is characterized in that: The image scrambling algorithm is implemented based on the pixel exchange mechanism. Each pixel in the R, G, and B color space is exchanged with a certain pixel in turn. The exchange object is selected in a pseudo-random manner. Pseudo-random coordinates are generated based on logistic chaotic mapping. Three concurrent threads generate the x-coordinate, y-coordinate and color channel that determine the pixel position respectively.

4. According to claim 3, a chaos-based parallel digital image encryption algorithm is characterized in that: The mathematical expression of the logistic chaos map is: x n+1 =μx n (1-x n ),x n ∈[0,1],∈￥,μ∈[0,4] where x n+1 Expressed as the proportion of the next generation population, x n is the number of the nth generation population, and μ is a positive real number.

5. The chaos-based parallel digital image encryption algorithm according to claim 1 is characterized in that: The diffusion stage generates a key stream based on the Lorenz system. The key streams generated by the three threads are used for bidirectional diffusion operations of the three color channels R, G, and B. The mathematical expression of the Lorenz system is: Among them, x, y, z are state variables, t represents time, σ, ρ, β are system parameters, and when σ=10, ρ=28, β=8 / 3, the system is in a chaotic state; When solving the Lorenz system, the 4th-order Runge-Kutta method is used, and the specific solution formula is: in h is the step length; A bidirectional diffusion mechanism is used to improve the speed of the encryption system. The diffusion process consists of two independent diffusion stages with different directions. In the first stage of the bidirectional diffusion process, similar to the traditional diffusion method, the value of each pixel is changed in order from left to right and from top to bottom. A small change at a certain point (M′, N′) will diffuse to all subsequent points of the point. In the second stage of diffusion, the value of each pixel is changed in order from bottom to top and from right to left. This small difference in the plaintext image is diffused to the entire ciphertext image through multiple difference points obtained in the first stage.

6. The chaos-based parallel digital image encryption algorithm according to claim 1 is characterized in that: The specific steps of implementing pixel scrambling in the R, G, and B color spaces in step S2 are to create three threads and call the following function three times. The function form is: hHandle[iThrd]=(HANDLE)_beginthreadex(NULL,0,ThreadWorkerEn_permutation_key,&threadArg[iThrd],CREATE_SUSPENDED,NULL) Among them, ThreadWorkerEn_permutation_key is the thread task function; Since the execution order of threads is not controlled by the user, a thread number is assigned to each thread to complete a fixed task. The thread number is defined in the custom thread parameter structure threadArg, and the logistic initial values ​​of the three threads are generated by the chaotic map iteration; Set the priority of the three threads by calling the system function SetThreadPriority(HANDLE,int).

7. The chaos-based parallel digital image encryption algorithm according to claim 6 is characterized in that: Set the affinity of the three threads by calling the system function SetThreadAffinityMask(HANDLE,DWORD); Since the thread is in a suspended state when it is created, call the system function ResumeThread(Handle) to resume the execution of the thread and start the scrambling operation; The thread task function needs to iterate the logistic map 3*W*H times to generate scrambled coordinates for the R, G, and B components, where W is the width of the image and H is the height of the image. The quantization method of the pseudo-random coordinates is as follows: Among them, key_x, key_y, key_color_comp are the current values ​​of the logistic mapping state variables, x-coor, y-coor, and color-comp represent the row, column, and color channel of the exchange object respectively; Call the system function WaitForMultipleObjects(DWORD,constHandle*,BOOL,DWORD) to wait for the completion of three threads; Call the system function CloseHandle(HANDLE) to end the three threads.

8. The chaos-based parallel digital image encryption algorithm according to claim 1 is characterized in that: The diffusion operation step in step S4 specifically restarts the thread and specifies the thread task as the diffusion function ThreadWorkerEn(void*); Assign initial values ​​to the Lorenz systems in the three threads through KeyGeneratorForEachThread_diffusion(ThreadArg*). Similar to the scrambling process, threads 0, 1, and 2 complete the diffusion operations of the three color channels R, G, and B respectively; set the priorities of the three threads by calling the system function SetThreadPriority(HANDLE, int); set the affinity of the three threads by calling the system function SetThreadAffinityMask(HANDLEDWORD); call the system function ResumeThread(Handle) to resume the execution of the threads; the three thread task functions use the Runge-Kutta method to solve the Lorenz system. According to the current values ​​of the three state variables of the Lorenz system, the following quantization method is used to obtain the three key stream elements, and the quantization form is: The Lorenz system is solved by using the Runge-Kutta method.

9. The chaos-based parallel digital image encryption algorithm according to claim 8, characterized in that: Use the generated key stream elements to encrypt the pixels. The encryption formula is: where c3× (n-1)+1 is the ciphertext pixel value, k xn is the quantized key stream element value, p3× (n-1)+1 is the plaintext pixel value.

10. A chaos-based parallel digital image encryption algorithm according to claim 9, characterized in that: The diffusion process is a two-round operation. The first round of diffusion is from left to right, and the second round is from bottom to top. This diffusion method is more efficient than other similar diffusion methods. Call the system function WaitForMultipleObjects(DWORD,constHandle*,BOOL,DWORD) to wait for the end of the three threads; call the system function CloseHandle(HANDLE) to end the three threads and complete the diffusion operation.

Images