CN104008520B - 基于sha-384函数、时空混沌系统、量子混沌系统和神经网络的彩色图像加密方法 - Google Patents

Abstract

本发明涉及一种基于SHA-384函数、时空混沌系统、量子混沌系统和神经网络的彩色图像加密方法，包括：利用SHA-384函数对原始彩色图像I₀进行计算，得到哈希值作为密钥，利用哈希值、CML耦合映像格子和一维Logistic混沌映射产生混沌序列，利用混沌序列对I₀的三基色分量的高四位图像进行位级行、列置乱，得到置乱图像I₁；利用Logistic量子混沌系统生成用于加密置乱图像的混沌序列，并结合神经网络对I₁的三基色分量的所有像素值进行并行扩散处理，得到最终的密文图像I₂。上述方法大大增加了密钥空间，使得安全性、加密效果和密钥敏感性更高，抗攻击能力更强，置乱过程加密时间更短，并更易于硬件实现。

Description

基于SHA-384函数、时空混沌系统、量子混沌系统和神经网络的彩色图像加密方法

技术领域

本发明涉及一种加密方法，特别是涉及一种基于SHA-384函数、时空混沌系统、量子混沌系统和神经网络的彩色图像加密方法。

背景技术

随着多媒体和网络技术的飞速发展，越来越多的多媒体信息，如音频、视频，特别是图像信息需要通过网络传输，随之而来的信息安全和保密问题就显得越来越重要。图像信息具有数据量大、相邻像素相关性强、冗余度高等特点，传统的加密方法，如DES、AES和RSA等都是针对一维数据而设计的，主要用于文本信息的加密，不适用于图像数据的加密。而混沌系统具有随机性、确定性、遍历性和对初值的高度敏感性等特点，可以设计出密钥空间大、加密流随机性强的加密算法，特别适合图像加密。因此，混沌图像加密已经成为了目前图像信息安全的研究热点，具有巨大的应用潜力。

1998年，美国学者Fridrich提出了置乱-扩散的经典图像加密模式。在置乱阶段，图像中的每个像素点的位置以一种伪随机的方式被打乱，但不改变图像像素值；在扩散阶段，使用混沌系统生成密钥来掩盖明文，从而改变原始图像各像素点的像素值，使得窃密者无法辨认，从而实现图像加密的目的。许多图像加密算法都采用这种加密模式，具有良好的安全性能。最近有学者提出位级置乱加密方法，在图像像素值的二进制位级进行加密，不仅可以置乱图像像素位置，而且可以改变图像像素值，可以有效提高加密效果，增加安全性。不过，目前的图像位级置乱加密算法中通常把像素值的高四位和低四位都进行置乱，而图像的信息主要集中在高四位。研究表明，高四位约集中了图像信息的94％，低四位则仅为6％。因此，对图像像素的高四位和低四位不加区别的都进行置乱加密无疑大大增加了硬件开销，延长了加密时间，不利用加密算法的实际应用。

以往研究的混沌加密算法大多数基于低维混沌系统，虽然低维混沌系统由于形式简单而具有计算时间短的优点，但鉴于有限计算精度的限制，低维混沌系统存在周期小和周期轨道少的不足，而时空混沌系统可以完美解决这些问题。此外，时空混沌系统具有较大的参数空间、更多的正的Lyapunov指数，更高的随机性和更多的混沌序列，产生的混沌序列也更加难以估计，并且容易批量并行产生。因此，时空混沌系统更适用于图像加密。最近，量子混沌系统引起了人们的关注，量子映射类似经典映射，具有对初始条件灵敏依赖的典型特征，开始被人们用于图像加密中。此外，鉴于神经网络的并行运算特点，可有效降低加密时间，提高加密效率，也被人们用于图像加密中。

发明内容

本发明要解决的技术问题是提供一种基于SHA-384函数、时空混沌系统、量子混沌系统和神经网络的彩色图像加密方法，能够大大增加密钥空间，使得安全性、加密效果和密钥敏感性更高，抗攻击能力更强，置乱过程加密时间更短，并更易于硬件实现。

本发明的技术方案是：

一种基于SHA-384函数、时空混沌系统、量子混沌系统和神经网络的彩色图像加密方法，包括以下步骤：

(1)输入RGB格式的图像大小为M×N的原始彩色图像I₀；

(2)利用SHA-384函数、时空混沌系统和一维混沌映射生成混沌序列，对所述彩色图像I₀进行位级置乱加密，得到加密图像I₁；

(3)利用量子混沌系统生成混沌序列，并结合神经网络对所述加密图像I₁进行扩散加密处理，得到最终的密文图像I₂。

上述基于SHA-384函数、时空混沌系统、量子混沌系统和神经网络的彩色图像加密方法，对于步骤(2)，其中的时空混沌系统为CML耦合映像格子，其动力学方程为

$\left\{\begin{array}{c}{x}_{n+1}\left(i\right)=(1-\mathrm{\ϵ})f\left(x_n\left(i\right)\right)+\frac{\mathrm{\ϵ}}{2}\×(f\left(x_n(i-1)\right)+f\left(x_n(i+1)\right))\\ f\left(x_n\right)=a{x}_n(1-x_n)\end{array}\right.$

其中的一维混沌映射为一维Logistic混沌映射

x_n+1＝kx_n(1-x_n)，x_n∈(0,1)

其中，n是离散时间坐标，i是格点坐标，并且i＝1,2,...,L；L为格点数，ε∈(0,1)是格点间的耦合强度因子，x_n(i)代表第i个格点在n时间的状态，x_n为Logistic混沌映射的第n次迭代量，系统参数a∈(3.5699456,4]，系统参数k∈(3.5699456,4]，Logistic映射呈现混沌特性；

并且，步骤(2)中利用SHA-384函数、CML耦合映像格子和一维Logistic混沌映射对彩色图像进行位级置乱加密的具体步骤为：

2.1)利用SHA-384函数对所述原始彩色图像I₀进行计算，得到一组384位的哈希值作为密钥，并将384位的哈希值从二进制转化为十六进制，得到96个十六进制数；

2.2)将哈希值互不重叠平均分割为3组，每组32个十六进制数，将各组元素分别转化为十进制数，并计算各组元素之和Sum(j)，其中j＝1,2,3；然后，通过以下公式计算出x₀(1)、x₀(2)和x₀(3)，作为CML耦合映像格子的初始值：

x₀(j)＝(mod(Sum(j),256))/256，j＝1,2,3

式中，mod(Sum(j),256)表示返回Sum(j)除以256的余数；

2.3)选定CML耦合映像格子的系统参数ε₀、a₀，在不同的初值x₀(1)、x₀(2)和x₀(3)下产生长度为(m≥500)的三个实值混沌序列，其中M为原始彩色图像I₀的行数，舍弃前面的m个数值以避免有害的影响，得到三个实值混沌序列D₁、D₂和D₃；

2.4)对D₁、D₂和D₃的原子序列分别按照升序重新排列，得到新的子序列，将原子序列中每个元素所在位置序号替换新的子序列中的对应元素，最终得到长度为M的三个置乱序列TM、TN、TP：

$\left\{\begin{array}{c}\mathrm{TM}=\{{\mathrm{TM}}_1,{\mathrm{TM}}_2,...,{\mathrm{TM}}_M\}\\ \mathrm{TN}=\{{\mathrm{TN}}_1,{\mathrm{TN}}_2,...,{\mathrm{TN}}_M\}\\ \mathrm{TP}=\{{\mathrm{TP}}_1,{\mathrm{TP}}_2,..,{\mathrm{TP}}_M\}\end{array}\right.$

并且，这三个序列中每个元素的元素值代表该位置上的数在所有元素中的位置；

2.5)选取系统参数k₁₀和初始值x₁₀，迭代求解一维Logistic混沌系统得到长度为(m₁≥500)的实值混沌序列，其中N为原始彩色图像I₀的列数，舍弃前面的m₁个数值，得到实值混沌序列Z₀，并将混沌序列Z₀拆分为三个大小为4N的子序列Z₁、Z₂和Z₃；

2.6)将混沌序列Z₀、Z₁、Z₂和Z₃的原子序列分别按照升序重新排列，得到新的子序列，同时将原子序列中每个元素所在位置序号替换新的子序列中的对应元素，最终分别得到长度为12N的置乱序列IN和长度均为4N的置乱序列INX，INY和INZ：

$\left\{\begin{array}{c}\mathrm{IN}=\{{\mathrm{IN}}_1,{\mathrm{IN}}_2,..,{\mathrm{IN}}_{12N}\}\\ \mathrm{INX}=\{{\mathrm{INX}}_1,{\mathrm{INX}}_2,...,{\mathrm{INX}}_{4N}\}\\ \mathrm{INY}=\{{\mathrm{INY}}_1,{\mathrm{INY}}_2,...,{\mathrm{INY}}_{4N}\}\\ \mathrm{INZ}=\{{\mathrm{INZ}}_1,{\mathrm{INZ}}_2,...,{\mathrm{INZ}}_{4N}\}\end{array}\right.$

并且，这四个序列中每个元素的元素值代表该位置上的数在所有元素中的位置；

2.7)选取参数k₂₀和初始值x₂₀，迭代求解一维Logistic混沌系统得到长度为(m₂≥500)的实值混沌序列，舍弃掉前面的m₂个数值，得到实值序列H₀；

2.8)将H₀的原子序列按升序重新排列，得到新的子序列，同时将原子序列中每个元素所在位置序号替换新的子序列中的对应元素，最终得到长度为3M的置乱序列TH＝{TH₁,TH₂,...,TH_3M}，并且序列中每个元素的元素值代表该位置上的数在所有元素中的位置；

2.9)分离彩色明文图像I0的R、G、B三基色分量得到三个大小为M×N的矩阵图像I₀R、I₀G和I₀B，把I₀R图像中的像素值从十进制转化为二进制，得到8个位级图像Rpic₁至Rpic₈,其中每个图像的大小为M×N，然后提取出高四位的四个矩阵Rpic₈、Rpic₇、Rpic₆和Rpic₅，并将图像Rpic₈、Rpic₇、Rpic₆和Rpic₅按照顺序从左到右横向排列构成矩阵R^H＝[Rpic₈,Rpic₇,Rpic₆,Rpic₅]，其中矩阵R^H的大小为M×4N，并保留低四位的Rpic₄、Rpic₃、Rpic₂和Rpic₁四个矩阵，每个矩阵大小为M×N；

2.10)依照与步骤2.9)相同的方法，变换I₀G图像，得到它的8个大小为M×N的位级图像Gpic₁至Gpic₈，提取出高四位矩阵重组得到新的矩阵G^H＝[Gpic₈,Gpic₇,Gpic₆,Gpic₅]，G^H大小为M×4N，并保留Gpic₁至Gpic₄四个矩阵，每个矩阵大小为M×N；变换I₀B图像，得到它的8个大小为M×N的位级图像Bpic₁至Bpic₈，提取出高四位矩阵重组得到矩阵B^H＝[Bpic₈,Bpic₇,Bpic₆,Bpic₅]，B^H大小为M×4N，并保留Bpic₁至Bpic₄四个矩阵，每个矩阵大小为M×N；

2.11)将图像大小为M×4N的R^H、G^H和B^H三个图像从左到右横向排列构成矩阵X₁，大小为M×12N，对图像X₁进行列方向行置乱操作，具体为：对于X₁的第w列，其中1≤w≤12N，当mod(w,3)＝0时，则按置乱序列TM＝{TM₁,TM₂,...,TM_M}重新排列第w列的所有元素，即移动第w列中的第TM₁行元素到第一行，第TM₂行元素到第二行，直至所有元素全部被置乱；当mod(w,3)＝1时，则按置乱序列TN＝{TN₁,TN₂,...,TN_M}重新排列第w列的所有元素，即移动第w列中的第TN₁行元素到第一行，第TN₂行元素到第二行，直至所有元素全部被置乱；当mod(w,3)＝2时，则按置乱序列TP＝{TP₁,TP₂,...,TP_M}重新排列第w列的所有元素，即移动第w列中的第TP₁行元素到第一行，第TP₂行元素到第二行，直至所有元素全部被置乱；以此类推，直到X₁中的每一列的所有元素均被置乱，得到大小为M×12N的图像矩阵X₂；

2.12)根据置乱序列IN＝{IN₁,IN₂,...,IN_12N}对二进制图像X₂进行整体列置乱，即将X₂的第IN₁列移动到第一列，第IN₂列移动到第二列，第IN_n列元素移到第n列，以此类推，直到X₂中的每一列都被置乱，从而得到置乱后大小为M×12N的图像X₃；

2.13)把图像X₃从左到右进行分割，分割为三个大小为M×4N的图像R^H1、G^H1和B^H1，将R^H1、G^H1和B^H1三个图像从上到下纵向排列重组得到大小为3M×4N的图像X₄，然后对X₄进行行方向列置乱操作，具体为：对于X₄的第v行，其中1≤v≤3M，当mod(v,3)＝0时，则按置乱序列INX＝{INX₁,INX₂,...,INX_4N}重新排列第v行的所有元素，即移动第v行中的第INX₁列元素到第一列，第INX₂列元素到第二列，直至所有元素全部被置乱；当mod(v,3)＝1时，则按置乱序列INY＝{INY₁,INY₂,...,INY_4N}重新排列第v行的所有元素，即移动第v行中的第INY₁列元素到第一列，第INY₂列元素到第二列，直至所有元素全部被置乱；当mod(v,3)＝2时，则按置乱序列INZ＝{INZ₁,INZ₂,...,INZ_4N}重新排列第v行的所有元素，即移动第v行中的第INZ₁列元素到第一列，第INZ₂列元素到第二列，直至所有元素全部被置乱；以此类推，直到X₄中的每一行的所有元素都被置乱，得到大小为3M×4N的图像矩阵X₅；

2.14)利用置乱序列TH＝{TH₁,TH₂,...,TH_3M}对X₅进行整体行置乱，即将X₅的第TH₁行移动到第一行，第TH₂行移动到第二行，第TH_n行元素移到第n行，以此类推，直到X₅中的每一行都被置乱，得到置乱后大小为3M×4N的图像X₆；

2.15)将图像矩阵X₆从上到下进行分割，分割成3个大小为M×4N的矩阵R^H2、G^H2和B^H2，将图像R^H2与步骤2.10)中保留的Bpic₄至Bpic₁四个矩阵从左到右横向排列，组成置乱后的二值图像R′，把像素值从二进制转换成十进制，得到大小为M×N的图像R″；将图像G^H2与步骤2.9)中保留的Rpic₄至Rpic₁四个矩阵从左到右横向排列，组成置乱后的二值图像G′，把像素值从二进制转换成十进制，得到大小为M×N的图像G″；将图像B^H2与步骤2.10)中保留的Gpic₄-Gpic₁四个矩阵从左到右横向排列，组成置乱后的二值图像B′，把像素值从二进制转换成十进制，得到大小为M×N的图像B″；

2.16)将图像R″、G″和B″进行合并，即I₁(1:M,1:N,1)＝R″(1:M,1:N)，I₁(1:M,1:N,2)＝G″(1:M,1:N)，I₁(1:M,1:N,3)＝B″(1:M,1:N)，从而得到置乱后的图像I₁。

上述基于SHA-384函数、时空混沌系统、量子混沌系统和神经网络的彩色图像加密方法，在步骤(3)中，所述量子混沌系统为Logistic量子混沌系统，其动力学方程为

$\left\{\begin{array}{c}{x\left(1\right)}_{n+1}=r(x{\left(1\right)}_n-{\left|x{\left(1\right)}_n\right|}^2)-r*x{\left(2\right)}_n\\ x{\left(2\right)}_{n+1}=-x{\left(2\right)}_n*e^{-2b}+e^{-b}*r*[(2-x{\left(1\right)}_n-x{\left(1\right)}_n^{*})*x{\left(2\right)}_n-x{\left(1\right)}_n*x{\left(3\right)}_n^{*}-x{\left(1\right)}_n^{*}*x{\left(3\right)}_n]\\ x{\left(3\right)}_{n+1}=-x{\left(3\right)}_n*e^{-2b}+e^{-b}*r*[2*(1-x{\left(1\right)}_n^{*})*x{\left(3\right)}_n-2*x{\left(1\right)}_{n}x{\left(2\right)}_n-x{\left(1\right)}_n]\end{array}\right.$

其中，参数r∈(3.74,4.00)，参数b≥3.5，x(1)_n、x(2)_n及x(3)_n为系统的状态，且x(1)_n∈(0,1)，x(2)_n∈(0,0.2469)，x(3)_n∈(0,0.2469)，和分别为x(1)_n和x(3)_n的复共轭；

并且，利用Logistic量子混沌系统对图像I₁进行加密的具体步骤为：

3.1)选取参数r₀、b₀，在三组不同初始值x(1)₀、x(2)₀、x(3)₀，x(1)′₀、x(2)′₀、x(3)′₀和x(1)″₀、x(2)″₀、x(3)″₀下，迭代Logistic量子混沌映射得到长度为(m₃≥500)的9个实值混沌序列，舍弃掉前面的m₃个数值，得到实值序列K1、K2、K3、K4、K5、K6、K7、K8、K9；

3.2)将经过步骤2.15)后得到的大小为M×N的图像R″、G″和B″转换为大小为1×MN的实值序列R1、G1和B1；设定神经网络输入为A_z＝[R1(z)；G1(z)；B1(z)]，其中R1(z)、G1(z)和B1(z)为实值序列R1、G1和B1的第z个元素，A_z为神经网络的第z个输入，并且z＝1,2,...,MN；对序列K1、K2、K3、K4、K5、K6、K7、K8、K9进行运算，得到神经网络的权值矩阵W_q为

$W_q=0.5\left[\begin{array}{ccc}K1\left(q\right)& K4\left(q\right)& K7\left(q\right)\\ K2\left(q\right)& K5\left(q\right)& K8\left(q\right)\\ K3\left(q\right)& K6\left(q\right)& K9\left(q\right)\end{array}\right]+0.5\left[\begin{array}{ccc}1& 1& 1\\ 1& 1& 1\\ 1& 1& 1\end{array}\right]$

其中，q代表实值序列K1、K2、K3、K4、K5、K6、K7、K8、K9中的第q个元素，且q＝1,2,...,MN；

3.3)利用权值矩阵W_q对神经网络的输入A_z按照下式处理，得到神经网络的输出Y₁，其中它的第p个元素Y_1p为：

Y1_p＝W_q*A_z+B_p，其中p＝1,2,...,MN，并且p＝q＝z

式中，神经网络的阀值量B_p为全零矩阵，处理后得到输出量为Y_1p＝[R1¹(p)；G1¹(p)；B1¹(p)]，R1¹(p)、G1¹(p)和B1¹(p)分别为处理后的图像第p个像素的R、G和B分量的像素值；

3.4)设置参数n₁和n₂，对于经步骤3.3)后所得到的矩阵Y₁，按照下式将其所有元素数值都转换到0到255之间，得到新的矩阵Y₂，同时得到由Y₂中各元素的整数部分所组成的矩阵Y₃和由Y₂中各元素的小数部分所组成的矩阵Y₄：

$\left\{\begin{array}{c}{Y}_{2p}=n_1\×Y_{1p}+n_2\\ Y_{3p}=\mathrm{floor}\left(Y_{2p}\right),p=\mathrm{1,2},...,\mathrm{MN}\\ Y_{4p}=Y_{2p}-Y_{3p}\end{array}\right.$

其中，floor(s)函数表示返回距离s最近的小于或等于s的整数；转换后得到Y_2p＝[R1²(p)；G1²(p)；B1²(p)]，整数部分为Y_3p＝[R1³(p)；G1³(p)；B1³(p)]，小数部分为Y_4p＝[R1⁴(p)；G1⁴(p)；B1⁴(p)]，Y_1p、Y_2p、Y_3p、Y_4p分别为Y₁、Y₂、Y₃、Y₄的第p个元素，R1²(p)、G1²(p)、B1²(p)分别为转换后的图像第p个像素的R、G和B分量的像素值，R1³(p)、G1³(p)、B1³(p)分别为转换后的图像第p个像素的R、G和B分量的像素值的整数部分，R1⁴(p)、G1⁴(p)、B1⁴(p)分别为转换后的图像第p个像素的R、G和B分量的像素值的小数部分；

3.5)选取混沌序列K1、K4、K7，每个序列大小为1×MN，利用下式对混沌序列K1、K4、K7中的每个元素都进行处理，把三个实值序列的每个元素数值都转换到0到255之间，得到改进的实值序列K1¹、K4¹和K7¹，其中q＝1,2,...,MN；

$\left\{\begin{array}{c}{K1}^1\left(q\right)=\mathrm{mod}(\mathrm{floor}(K1\left(q\right)*10^14),256)\\ {K4}^1\left(q\right)=\mathrm{mod}(\mathrm{floor}(K4\left(q\right)*10^14),256)\\ {K7}^1\left(q\right)=\mathrm{mod}(\mathrm{floor}(K7\left(q\right)*10^14),256)\end{array}\right.$

3.6)将K1¹、K4¹和K7¹按照顺序从上到下进行组合，得到大小为3×MN的矩阵E，对矩阵Y₃中的各个元素按照下式进行加密操作，得到新的矩阵Y₅，即矩阵Y₅中的第p个元素Y_5p＝[R1⁵(p)；G1⁵(p)；B1⁵(p)]，其中R1⁵(p)、G1⁵(p)和B1⁵(p)分别为加密操作后的图像第p个像素的R、G和B分量的像素值的整数部分：

$Y_{5p}=Y_{3p}\⊕E_p,p=\mathrm{1,2},...,\mathrm{MN}$

式中，“”为异或运算操作符，Y_3p、E_p、Y_5p分别是Y₃、E、Y₅的第p个元素,E_p＝[K1¹(p)；K4¹(p)；K7¹(p)]；

3.7)利用下式对Y₅中的每个元素都进行处理，得到矩阵C：

C_p＝f(Y_5p,Y_4p)＝Y_5p+Y_4p，p＝1,2,...,MN

其中神经网络的激活函数f为加法运算，C_p是C的第p个元素，同时神经网络的最终输出C_p为图像的第p个像素的密文像素值，最终的加密结果C_p＝[R1′(p)；G1′(p)；B1′(p)]，其中R1′(p)为加密后的第p个像素的红色分量，G1′(p)为加密后的第p个像素的绿色分量，B1′(p)为加密后的第p个像素的蓝色分量；

3.8)将经步骤3.7)所得到的所有像素的红色分量、绿色分量和蓝色分量，按行排列分别转换为大小为M×N的矩阵，得到扩散后图像的三基色分量I₂R、I₂G和I₂B，从而最终得到加密图像I₂。

本发明的有益效果是：

(1)本发明通过采用SHA-384函数、时空混沌系统和量子混沌系统的组合，并结合了神经网络，从而大大增加了密钥空间，进而具有密钥数目多、密钥空间大和密钥敏感性高的特点，能够有效地抵抗穷举攻击，使得图像加密算法的安全性更高；

(2)本发明利用SHA-384函数对明文信息进行计算产生384位的安全密钥，对384位哈希值进行运算产生时空混沌系统的初始值，使得算法依赖于明文，要攻击密文就必须知道当前密文的明文图像信息，从而可以有效抵抗选择明文和选择密文攻击，进一步提高了算法的安全性；

(3)本发明置乱过程中对明文图像R、G、B三个分量的高四位进行联合加密，大大减少了计算量，缩短了加密时间，降低了三个分量之间的相关性，扩散过程中利用神经网络的并行处理机制对图像每个像素的R、G、B分量进行逐一联合扩散，从而有效地降低了三个分量之间的相关性，增强了加密效果，更进一步增强了算法的安全性，使得该算法可广泛应用于商业、医学、电子档案、遥感图像、国防军事等领域。

附图说明

下面结合附图对本发明的具体实施方式作进一步详细的说明。

图1为本发明的彩色图像加密方法流程图；

图2为本发明的置乱加密算法的流程图；

图3为本发明的扩散加密算法的流程图，其中：(a)为生成扩散过程所需的权值矩阵和扩散序列的流程图，(b)为扩散过程流程图；

图4中：(a)为实施例1所用原始彩色图像，(b)为置乱后的图像，(c)为对置乱图像加密后的图像，(d)为密钥正确时的解密图像，(e)为参数密钥错误时的解密图像，(f)为图像密钥错误时的解密图像；

图5中：(a)为实施例1所用原始彩色图像，(b)为原始图像R分量的直方图，(c)为原始图像G分量的直方图，(d)为原始图像B分量的直方图；

图6中：(a)为实施例1利用本发明方法加密后的加密图像，(b)为加密图像R分量的直方图，(c)为加密图像G分量的直方图，(d)为加密图像B分量的直方图；

图7中：(a)为实施例1所用原始图像R分量水平方向上相邻像素的相关性分析图，(b)为加密图像R分量水平方向上相邻像素的相关性分析图；

图8中：(a)为实施例2所用原始彩色图像，(b)为置乱后的图像，(c)为对置乱图像加密后的图像，(d)为密钥正确时的解密图像，(e)为参数密钥错误时的解密图像，(f)为图像密钥错误时的解密图像；

图9中：(a)为实施例2所用原始彩色图像，(b)为原始图像R分量的直方图，(c)为原始图像G分量的直方图，(d)为原始图像B分量的直方图；

图10中：(a)为实施例2利用本发明方法加密后的加密图像，(b)为加密图像R分量的直方图，(c)为加密图像G分量的直方图，(d)为加密图像B分量的直方图；

图11中：(a)为实施例2所用原始图像R分量水平方向上相邻像素的相关性分析图，(b)为加密图像R分量水平方向上相邻像素的相关性分析图。

具体实施方式

实施例1：在本实施例中，采用的编程软件为Matlab R2009a，选取图4(a)所示的大小为512×512的LenaRGB标准彩色图像为实验对象，对LenaRGB彩色图像进行加密的具体过程如下：

1.输入原始LenaRGB彩色图像，用I₀＝imread('LenaRGB.bmp')读取图像信息，利用SHA-384函数对原始彩色图像I₀进行计算，得到一组384位的哈希值作为密钥，并将384位的哈希值从二进制转化为十六进制，得到96个十六进制数，即B5E9C5E D D3B C800F62C F A894A A B F A D17B29B5D B C7089315438D26728A607F41F72B70A7D1133F62B A E427C C E78097029。将哈希值平均分割为3组，每组32个十六进制数，将各组元素分别转化为十进制数，并计算各组元素之和Sum(j)，其中j＝1,2,3，通过下面公式计算出x₀(1)、x₀(2)和x₀(3)，作为CML耦合映像格子的初始值：

x₀(j)＝(mod(Sum(j),256))/256,其中j＝1,2,3

现具体说明，利用384位哈希值产生CML耦合映像格子初始值的方法如下：

A1：将第一组的32个十六进制数'B'，'9'，'E'，'3'，'8'，'F'，'C'，'8'，'A'，'F'，'1'，'2'，'5'，'C'，'8'，'1'，'3'，'2'，'2'，'6'，'F'，'F'，'B'，'A'，'1'，'3'，'2'，'E'，'7'，'E'，'0'，'0'转化为十进制数11，9，14，3，8，15，12，8，10，15，1，2，5，12，8，1，3，2，2，6，15，15，11，10，1，3，2，14，7，14，0，0，然后求出这32个十进制数之和，除以256后的余数再除以256，得到x₀(1)＝0.9336。

A2：原理同A1，将第二组十六进制数'5'，'C'，'D'，'B'，'0'，'6'，'F'，'9'，'A'，'A'，'7'，'9'，'D'，'7'，'9'，'5'，'8'，'6'，'8'，'0'，'4'，'7'，'7'，'7'，'1'，'F'，'B'，'4'，'C'，'7'，'9'，'2'转化为十进制数5，12，13，11，0，6，15，9，10，10，7，9，13，7，9，5，8，6，8，0，4，7，7，7，1，15，11，4，12，7，9，2，然后求出这32数之和，除以256后的余数再除以256，得到初始值x₀(2)＝0.9727。

A3：同上，将第三组十六进制数'E'，'5'，'D'，'C'，'0'，'2'，'A'，'4'，'B'，'D'，'B'，'B'，'B'，'0'，'3'，'4'，'D'，'7'，'A'，'7'，'1'，'2'，'0'，'D'，'3'，'6'，'A'，'2'，'C'，'8'，'7'，'9'转化为十进制数14，5，13，12，0，2，10，4，11，13，11，11，11，0，3，4，13，7，10，7，1，2，0，13，3，6，10，2，12，8，7，9，从而最终求出第三个初始值x₀(3)＝0.9141。

2.选用如下的CML耦合映像格子

$\left\{\begin{array}{c}{x}_{n+1}\left(i\right)=(1-\mathrm{\ϵ})f\left(x_n\left(i\right)\right)+\frac{\mathrm{\ϵ}}{2}\×(f\left(x_n(i-1)\right)+f\left(x_n(i+1)\right))\\ f\left(x_n\right)=a{x}_n(1-x_n)\end{array}\right.$

其中，n是离散时间坐标，i(i＝1,2,...,L)是格点坐标，L为格点数，ε∈(0,1)是格点间的耦合强度因子，x_n(i)代表第i个格点在n时间的状态，参数a∈(3.5699456,4]。

3.一维混沌映射使用一维Logistic混沌映射：

x_n+1＝kx_n(1-x_n)，x_n∈(0,1)

其中，系统参数k∈(3.5699456,4]，Logistic映射呈现混沌特性。

4.选取初始值x₀(1)＝0.9336、x₀(2)＝0.9727和x₀(3)＝0.9141，选择系统参数ε₀＝0.1、a₀＝4，迭代入CML耦合映像格子生成长度为(m≥500)的实值混沌序列，抛弃前m＝500个值，从而得到长度为512的实值混沌序列D₁、D₂和D₃。这里将x₀(1)、x₀(2)、x₀(3)、ε₀、a₀、m作为密钥。

5.由于D₁、D₂、D₃的排列是杂乱无章的，对其按照升序重新排列，得到新的子序列，然后将原子序列中每个元素所在位置序号替换新的子序列中的对应元素，最终得到3个长度都为512的置乱序列TM、TN、TP。

$\left\{\begin{array}{c}\mathrm{TM}=\{{\mathrm{TM}}_1,{\mathrm{TM}}_2,...,{\mathrm{TM}}_{512}\}\\ \mathrm{TN}=\{{\mathrm{TN}}_1,{\mathrm{TN}}_2,...,{\mathrm{TN}}_{512}\}\\ \mathrm{TP}=\{{\mathrm{TP}}_1,{\mathrm{TP}}_2,..,{\mathrm{TP}}_{512}\}\end{array}\right.$

并且，这三个序列中每个元素的元素值代表该位置上的数在所有元素中的位置。

为进一步清楚阐述，举例如下：假设一个长度为7的序列P＝[12 10 4 21 26 5 1]，将其按照升序排列得到P＝[1 4 5 10 12 21 26]，然后再将原序列中每个元素所在位置序号替换新的子序列中的对应元素，从而得到置乱序列INP＝[7 3 6 2 1 4 5]。

6.选取系统参数k₁₀＝3.99和初始值x₁₀＝0.12345678912345，利用一维Logistic混沌系统生成长度为(m₁≥500)的实值混沌序列，抛弃前m₁＝500个数值，从而得到长度为6144的实值混沌序列Z₀，将混沌序列Z₀拆分为三个大小为2048的互不重叠的子序列Z₁、Z₂和Z₃。这里将k₁₀、x₁₀、m₁作为密钥。

7.对Z₀、Z₁、Z₂和Z₃按照升序重新排列，得到新的子序列，然后将原子序列中每个元素所在位置序号替换新的子序列中的对应元素，最终得到长度为6144、2048、2048和2048的置乱序列IN、INX、INY和INZ。

$\left\{\begin{array}{c}\mathrm{IN}=\{{\mathrm{IN}}_1,{\mathrm{IN}}_2,..,{\mathrm{IN}}_{6144}\}\\ \mathrm{INX}=\{{\mathrm{INX}}_1,{\mathrm{INX}}_2,...,{\mathrm{INX}}_{2048}\}\\ \mathrm{INY}=\{{\mathrm{INY}}_1,{\mathrm{INY}}_2,...,{\mathrm{INY}}_{2048}\}\\ \mathrm{INZ}=\{{\mathrm{INZ}}_1,{\mathrm{INZ}}_2,...,{\mathrm{INZ}}_{2048}\}\end{array}\right.$

8.选取参数k₂₀＝3.99和初始值x₂₀＝0.123456789，利用一维Logistic混沌系统生成长度为(m₂≥500)的实值混沌序列，抛弃前m₂＝500个值，从而得到长度为1536的实值混沌序列H₀。这里将k₂₀、x₂₀、m₂作为密钥。

9.对H₀按照升序重新排列，得到新的子序列，然后将原子序列中每个元素所在位置序号替换新的子序列中的对应元素，最终得到长度为1536的置乱序列TH。

TH＝{TH₁,TH₂,...,TH₁₅₃₆}

10.分离彩色图像I₀的R、G、B三基色分量得到三个大小为512×512的矩阵图像I₀R、I₀G和I₀B，把I₀R图像中的像素值从十进制转化为二进制，得到8个位级图像Rpic₁-Rpic₈，每个图像的大小为512×512，提取出高四位的四个矩阵Rpic₈、Rpic₇、Rpic₆和Rpic₅，将图像Rpic₈、Rpic₇、Rpic₆和Rpic₅按照顺序从左到右横向排列构成矩阵R^H＝[Rpic₈,Rpic₇,Rpic₆,Rpic₅]，矩阵R^H大小为512×2048，保留低四位的Rpic₄、Rpic₃、Rpic₂和Rpic₁四个矩阵(每个矩阵大小为512×512)。同样处理方法，变换I₀G图像，得到它的8个大小为512×512的位级图像Gpic₁-Gpic₈，提取出高四位矩阵重组得到新的矩阵G^H＝[Gpic₈,Gpic₇,Gpic₆,Gpic₅]，G^H大小为512×2048，保留Gpic₁-Gpic₄四个矩阵(每个矩阵大小为512×512)。变换B图像，得到它的8个大小为512×512的位级图像Bpic₁-Bpic₈，提取出高四位矩阵重组得到矩阵B^H＝[Bpic₈,Bpic₇,Bpic₆,Bpic₅]，B^H大小为512×2048，保留Bpic₁-Bpic₄四个矩阵(每个矩阵大小为512×512)。

11.将图像大小为512×2048的R^H、G^H和B^H三个图像从左到右横向排列构成矩阵X₁，大小为512×6144，对图像X₁进行列方向行置乱操作。具体地，假设w为X₁的第w列(1≤w≤6144)，当mod(w,3)＝0时，则按置乱序列TM＝{TM₁,TM₂,...,TM_M}重新排列第w列的所有元素，即移动第w列中的第TM₁行元素到第一行，第TM₂行元素到第二行，直至所有元素全部被置乱；当mod(w,3)＝1时，则按置乱序列TN＝{TN₁,TN₂,...,TN_M}重新排列第w列的所有元素，也就是移动第w列中的第TN₁行元素到第一行，第TN₂行元素到第二行，直至所有元素全部被置乱。当mod(w,3)＝2时，则按置乱序列TP＝{TP₁,TP₂,...,TP_M}重新排列第w列的所有元素，即移动第w列中的第TP₁行元素到第一行，第TP₂行元素到第二行，直至所有元素全部被置乱。以此类推，直到X₁中的每一列的所有元素都被置乱，得到图像矩阵X₂，大小为512×6144。为进一步清楚阐述，下面举一个例子说明步骤11列方向行置乱操作。

假设，3列7行的待处理矩阵 $A=\left[\begin{array}{ccc}1& 8& 15\\ 2& 9& 16\\ 3& 10& 17\\ 4& 11& 18\\ 5& 12& 19\\ 6& 13& 20\\ 7& 14& 21\end{array}\right],$ 三个置乱序列分别为 $\mathrm{IM}=\left[\begin{array}{c}2\\ 1\\ 7\\ 4\\ 3\\ 6\\ 5\end{array}\right],\mathrm{IN}=\left[\begin{array}{c}5\\ 7\\ 3\\ 6\\ 2\\ 4\\ 1\end{array}\right],$ $\mathrm{IP}=\left[\begin{array}{c}2\\ 1\\ 6\\ 3\\ 7\\ 4\\ 5\end{array}\right].$ 假设A矩阵的第一列按置乱序列IM移动，即第一列中第二行的元素2移到第一行元素1的位置，第一行元素1移到第二行元素2的位置，第七行元素7移到第三行元素3的位置，等等。第二列按置乱序列IN移动，即第二列中第五行元素12移到第一行元素8的位置，第七行元素14移到第二行元素9的位置，等等。第三列按置乱序列IP移动，即第三列第二行元素16移到第一行元素15的位置，第一行元素15移到第二行元素16的位置，第六行元素20移到第三行元素17的位置，等等。则改变后的矩阵 $A^{\′}=\left[\begin{array}{ccc}2& 12& 16\\ 1& 14& 15\\ 7& 10& 20\\ 4& 13& 17\\ 3& 9& 21\\ 6& 11& 18\\ 5& 8& 19\end{array}\right].$

12.根据置乱序列IN＝{IN₁,IN₂,...,IN₆₁₄₄}对二进制图像X₂进行整体列置乱，即将X₂的第IN₁列移动到第一列，第IN₂列移动到第二列，第IN_n列移到第n列，以此类推，直到X₂中的每一列都被置乱，得到置乱后的图像X₃，矩阵X₃大小为512×6144。

13.把图像X₃从左到右进行分割，分割为三个大小为512×2048的图像R^H1、G^H1和B^H1，将R^H1、G^H1和B^H1三个图像从上到下纵向排列重组得到大小为1536×2048的图像X₄，对X₄进行行方向列置乱操作。具体地，假设v代表X₄的第v行(1≤v≤1536)，当mod(v,3)＝0时，则按置乱序列INX＝{INX₁,INX₂,...,INX₆₁₄₄}重新排列第v行的所有元素，即移动第v行中的第INX₁列元素到第一列，第INX₂列元素到第二列，直至所有元素全部被置乱；当mod(v,3)＝1时，则按置乱序列INY＝{INY₁,INY₂,...,INY₆₁₄₄}重新排列第v行的所有元素，也就是移动第v行中的第INY₁列元素到第一列，第INY₂列元素到第二列，直至所有元素全部被置乱。当mod(v,3)＝2时，则按置乱序列INZ＝{INZ₁,INZ₂,...,INZ₆₁₄₄}重新排列第v行的所有元素，即移动第v行中的第INZ₁列元素到第一列，第INZ₂列元素到第二列，直至所有元素全部被置乱。以此类推，直到X₄中的每一行的所有元素都被置乱，得到大小为1536×2048的图像矩阵X₅。为进一步清楚阐述，下面举例说明本步骤：

假设3行7列的待处理矩阵 $A=\left[\begin{array}{ccccccc}1& 2& 3& 4& 5& 6& 7\\ 8& 9& 10& 11& 12& 13& 14\\ 15& 16& 17& 18& 19& 20& 21\end{array}\right],$ 三个置乱序列分别为IM＝[2 1 7 4 3 6 5]，IN＝[5 7 3 6 2 4 1]，IP＝[2 1 6 3 7 4 5]。假设A矩阵的第一行按置乱序列IM移动，即第一行中第二列的元素2移到第一列元素1的位置，第一列元素1移到第二列元素2的位置，第七列元素7移到第三列3的位置，等等。第二行按置乱序列IN移动，即第二行中第五列元素12移到第一列元素8的位置，第七列元素14移到第二列元素9的位置，等等。第三行按置乱序列IP移动，即第三行中第二列元素16移到第一列元素15的位置，第一列元素15移到第二列元素16的位置，第六列元素20移到第三列元素17的位置，等等。则置乱后的矩阵 $A^{\′}=\left[\begin{array}{ccccccc}2& 1& 7& 4& 3& 6& 5\\ 12& 14& 10& 13& 9& 11& 8\\ 16& 15& 20& 17& 21& 18& 19\end{array}\right].$

14.利用置乱序列TH＝{TH₁,TH₂,...,TH₁₅₃₆}对X₅进行整体行置乱，即将X₅的第TH₁行移动到第一行，第TH₂行移动到第二行，第TH_n行元素移到第n行，以此类推，直到X₅中的每一行都被置乱，得到置乱后的大小为1536×2048的图像X₆。

15.将图像矩阵X₆从上到下进行分割，分割成3个大小为512×2048的矩阵R^H2、G^H2和B^H2。将图像R^H2与步骤10保留的Bpic₄-Bpic₁四个矩阵从左到右横向排列，组成置乱后的二值图像R′，把像素值从二进制转换成十进制，得到大小为512×512的图像R″。将图像G^H2与步骤10保留的Rpic₄-Rpic₁四个矩阵从左到右横向排列，组成置乱后的二值图像G′，把像素值从二进制转换成十进制，得到大小为512×512的图像G″。将图像B^H2与步骤10保留的Gpic₄-Gpic₁四个矩阵从左到右横向排列，组成置乱后的二值图像B′，把像素值从二进制转换成十进制，得到大小为512×512的图像B″。将图像R″、G″和B″进行合并，即I₁(1:512,1:512,1)＝R″(1:512,1:512)，I₁(1:512,1:512,2)＝G″(1:512,1:512)，I₁(1:512,1:512,3)＝B″(1:512,1:512)，从而得到置乱后的图像I₁。

至此，便完成了原始彩色图像的位(bit)级置乱操作，置乱加密后的图像见图4(b)。

16.选用如下的Logistic量子混沌系统

$\left\{\begin{array}{c}{x\left(1\right)}_{n+1}=r(x{\left(1\right)}_n-{\left|x{\left(1\right)}_n\right|}^2)-r*x{\left(2\right)}_n\\ x{\left(2\right)}_{n+1}=-x{\left(2\right)}_n*e^{-2b}+e^{-b}*r*[(2-x{\left(1\right)}_n-x{\left(1\right)}_n^{*})*x{\left(2\right)}_n-x{\left(1\right)}_n*x{\left(3\right)}_n^{*}-x{\left(1\right)}_n^{*}*x{\left(3\right)}_n]\\ x{\left(3\right)}_{n+1}=-x{\left(3\right)}_n*e^{-2b}+e^{-b}*r*[2*(1-x{\left(1\right)}_n^{*})*x{\left(3\right)}_n-2*x{\left(1\right)}_{n}x{\left(2\right)}_n-x{\left(1\right)}_n]\end{array}\right.$

式中，参数r∈(3.74,4.00)，参数b≥3.5，x(1)_n∈(0,1)、x(2)_n∈(0,0.2469)和x(3)_n∈(0,0.2469)为系统的状态，和分别为x(1)_n和x(3)_n的复共轭。

对于神经网络，本发明采用由三个人工神经元组成的分布式并行处理的自适应非线性神经网络模型。神经网络简称人工神经网络，是由三个人工神经元组成的分布式并行处理的自适应非线性动力系统，每个神经元具有n个输入，其动力学方程表示为

$y_i=f(\underset{i=1}{\overset{n}{\mathrm{\Σ}}}{w}_i{x}_i+b_i)$

其中x_i为神经元的输入分量，w_i为神经元的权值分量，b_i为神经元的阀值分量，f为其激活函数，y_i为神经元的输出分量，并且i＝1,2...,n。

具体到本实施例，每个神经元具有3个输入，其动力学方程即可表示为

$y_i=f(\underset{i=1}{\overset{3}{\mathrm{\Σ}}}{w}_i{x}_i+b_i)$

17.选取参数r₀＝3.9，b₀＝4，在三组不同初始值x(1)₀＝0.4883、x(2)₀＝0.0234、x(3)₀＝0.0207，x(1)′₀＝0.5078、x(2)′₀＝0.0332、x(3)′₀＝0.0168，x(1)″₀＝0.4297、x(2)″₀＝0.0309、x(3)″₀＝0.0250下，迭代Logistic量子混沌映射得到长度为(m₃≥500)的9个实值混沌序列，舍弃掉前面的m₃＝500个数值，得到实值序列K1、K2、K3、K4、K5、K6、K7、K8、K9。这里将r₀，b₀、x(1)₀、x(2)₀、x(3)₀、x(1)′₀、x(2)′₀、x(3)′₀、x(1)″₀、x(2)″₀、x(3)″₀作为密钥。

18.将置乱后的大小为512×512的图像R″、G″和B″转换为大小为1×262144的实值序列R1、G1和B1，设定神经网络输入为A_z＝[R1(z)；G1(z)；B1(z)]，z代表实值序列R1、G1和B1中的第z个元素，z＝1,2,...,262144，同时z也是神经网络的第z个输入。对序列K1、K2、K3、K4、K5、K6、K7、K8、K9进行运算，得到权值矩阵W_q为

$W_q=0.5\left[\begin{array}{ccc}K1\left(q\right)& K4\left(q\right)& K7\left(q\right)\\ K2\left(q\right)& K5\left(q\right)& K8\left(q\right)\\ K3\left(q\right)& K6\left(q\right)& K9\left(q\right)\end{array}\right]+0.5\left[\begin{array}{ccc}1& 1& 1\\ 1& 1& 1\\ 1& 1& 1\end{array}\right]$

其中，q代表实值序列K1、K2、K3、K4、K5、K6、K7、K8、K9中的第q个元素，q＝1,2,...,262144。

19.利用权值矩阵W_q对神经网络的输入A_z按照下式处理，得到神经网络的输出Y₁，其中它的第p个元素Y_1p为：

Y_1p＝W_q*A_z+B_p，其中p＝1,2,...,262144，并且p＝q＝z

式中，神经网络的阀值量B_p为全零矩阵，处理后得到输出量为Y_1p＝[R1¹(p)；G1¹(p)；B1¹(p)]，R1¹(p)、G1¹(p)和B1¹(p)分别为处理后的图像第p个像素的R、G和B分量的像素值。

20.设置参数n₁＝0.2和n₂＝2，利用下式将Y₁的所有元素数值都转换到0到255之间，得到新的矩阵Y₂，同时得到Y₂中各元素的整数部分组成的矩阵Y₃和小数部分组成的矩阵Y₄：

$\left\{\begin{array}{c}{Y}_{2p}=n_1\×Y_{1p}+n_2\\ Y_{3p}=\mathrm{floor}\left(Y_{2p}\right),p=\mathrm{1,2},...,262144\\ Y_{4p}=Y_{2p}-Y_{3p}\end{array}\right.$

其中，floor(s)函数表示返回距离s最近的小于或等于s的整数；转换后得到Y_2p＝[R1²(p)；G1²(p)；B1²(p)]，整数部分为Y_3p＝[R1³(p)；G1³(p)；B1³(p)]，小数部分为Y_4p＝[R1⁴(p)；G1⁴(p)；B1⁴(p)]，Y_1p、Y_2p、Y_3p、Y_4p分别为Y₁、Y₂、Y₃、Y₄的第p个元素，R1²(p)、G1²(p)、B1²(p)分别为经过处理后的图像第p个像素的R、G和B分量的像素值，R1³(p)、G1³(p)、B1³(p)分别为经过处理后的图像第p个像素的R、G和B分量的像素值的整数部分，R1⁴(p)、G1⁴(p)、B1⁴(p)分别为经过处理后的图像第p个像素的R、G和B分量的像素值的小数部分。

21.选取混沌序列K1、K4、K7，每个序列大小为1×262144。对混沌序列K1、K4、K7中的每个元素都进行处理，即把三个实值序列的每个元素数值都转换到0到255之间，得到改进后的实值序列K1¹、K4¹和K7¹，其中q＝1,2,...,262144。

$\left\{\begin{array}{c}{K1}^1\left(q\right)=\mathrm{mod}(\mathrm{floor}(K1\left(q\right)*10^14),256)\\ {K4}^1\left(q\right)=\mathrm{mod}(\mathrm{floor}(K4\left(q\right)*10^14),256)\\ {K7}^1\left(q\right)=\mathrm{mod}(\mathrm{floor}(K7\left(q\right)*10^14),256)\end{array}\right.$

22.将K1¹、K4¹和K7¹按照顺序从上到下进行组合，得到大小为3×262144的矩阵E，接着对矩阵Y₃中的各个元素按照下式进行加密操作，得到新的矩阵Y₅,矩阵中的第p个元素Y_5p＝[R1⁵(p)；G1⁵(p)；B1⁵(p)]，其中R1⁵(p)、G1⁵(p)和B1⁵(p)分别为经过处理后的图像第p个像素的R、G和B分量的像素值的整数部分，

$Y_{5p}=Y_{3p}\⊕E_p,$ 其中p=1,2,...,262144

其中，操作符代表异或运算，Y_3p、E_p、Y_5p分别是Y₃、E、Y₅的第p个元素,E_p＝[K1¹(p)；K4¹(p)；K7¹(p)]。

23.对Y₅中的每个元素都进行处理，得到矩阵C：

C_p＝f(Y_5p,Y_4p)＝Y_5p+Y_4p，p＝1,2,...,262144

其中神经网络的激活函数f为加法运算，Y_4p、Y_5p、C_p分别是Y₄、Y₅、C的第p个元素；小数部分Y_4p＝[R1⁴(p)；G1⁴(p)；B1⁴(p)]，整数部分Y_5p＝[R1⁵(p)；G1⁵(p)；B1⁵(p)]，R1⁴(p)、G1⁴(p)、B1⁴(p)分别为经过处理后的图像第p个像素的R、G和B分量的像素值的小数部分，R1⁵(p)、G1⁵(p)和B1⁵(p)分别为经过处理后的图像第p个像素的R、G和B分量的像素值的整数部分；神经网络的最终输出C_p为图像的第p个像素的密文像素值，C_p为整数部分和小数部分之和，最终的加密结果C_p＝[R1′(p)；G1′(p)；B1′(p)]，R1′(p)为加密后的第p个像素的红色分量，G1′(p)为加密后的第p个像素的绿色分量，B1′(p)为加密后的第p个像素的蓝色分量。

24.以此类推，直到实值序列R1、G1和B1中的所有元素均被处理，然后将得到的所有像素的红色分量、绿色分量和蓝色分量按行排列分别转换为大小为512×512的矩阵，得到扩散后图像的三基色分量I₂R、I₂G和I₂B，从而最终得到加密图像I₂，见图4(c)。

图像解密过程与加密过程类似，只需按照与加密过程相逆的顺序进行运算即可恢复出原始彩色图像I₀。解密过程中，各个步骤所用CML耦合映像格子、一维Logistic混沌系统和Logistic量子混沌系统的参数、初始值和其它参数与加密过程中对应相同。当密钥正确时，解密图像见图4(d)。此外，图4(e)和4(f)为错误密钥下的解密图像，从图4(e)和4(f)难以辨认原始图像，可见本发明的图像加密算法具有很好的加密效果。

一个好的加密算法应该能够抵抗各种攻击，密钥空间足够大，密钥的敏感性足够高。下面对本发明的图像加密算法进行安全性分析。

(1)密钥空间大，足以抵抗穷举攻击

混沌系统对初始值有很高的敏感性，需要足够大的密钥空间来抵御穷举攻击，因此混沌加密算法的安全性主要依赖于密钥空间的大小。密钥具体包括：1)系统参数a₀、k₁₀、k₂₀、b₀、r₀、ε₀；2)时空混沌系统初始值x₀(1)、x₀(2)和x₀(3)和Logistic量子混沌映射初始值x(1)₀、x(2)₀、x(3)₀，x(1)′₀、x(2)′₀、x(3)′₀和x(1)″₀、x(2)″₀、x(3)″₀；3)384位的哈希值。在MatlabR2009a环境下，所有数据类型都采用精度为10位的双精度实数，则密钥空间至少为2³⁸⁴×10¹⁸⁰。因此，本发明的加密算法具有足够大的密钥空间，足以抵抗穷举攻击。

(2)密钥敏感性高

对于图4(c)所示的加密图像，图4(d)所示为当采用正确密钥时得到的清晰解密图像，可以精确恢复出原始图像。1)保持其它密钥参数不变，当h₀改变+10^-16，进行解密，附图4(e)所示为当h₀＝0.1234567890000001时的解密图像；2)保持其它密钥参数不变，将384位的哈希值的第四位由1变0，即图像的哈希值由B5E9C5E D D3B C800F62C F A894A A B F A D17B29B5D B C7089315438D26728A607F41F72B70A7D1133F62B A E427C C E78097029变为A5E9C5E D D3B C800F62C F A894A A B F A D17B29B5D B C7089315438D26728A607F41F72B70A7D1133F62B A E427C C E78097029，用改变后的哈希值进行解密，解密后的图像见图4(f)。从附图4(e)和4(f)容易看出，即使密钥存在微小差异，解密图像是类似于噪声的均匀图像，无法辨认出原始图像的任何信息。由此可见，本发明的加密算法具有高度的密钥敏感性。

(3)密文图像的灰度直方图平滑且均匀，抗统计分析攻击能力强。

直方图描述了数字图像中所有灰度级的像素出现的频率。一个好的图像加密算法加密得到的密文图像的灰度直方图应该平滑且均匀，以免信息的泄露。

图5所示为原始彩色图像及其R、G、B分量的直方图，图6所示为加密图像及其R、G、B分量的直方图。从图中可以看出，原始图像的像素分布很不均匀，而加密图像R、G和B分量的像素呈现均匀分布的特点，加密图像的像素值在[0,255]范围内取值概率均等。由此可见，该加密算法具有良好的抵抗统计分析攻击的能力。

(4)原始图像相邻像素高度相关，加密后图像相邻像素相关系数接近于0，基本不相关。

为了分析明文图像和密文图像相邻像素的相关性，引入相邻像素的相关系数。相关系数越大，说明相邻像素的相关性越大；反之，相邻像素的相关性越小。从图像中选取20000对水平方向相邻像素对，20000对垂直方向相邻像素对和20000对对角方向相邻像素对，用如下公式定量计算相邻像素的相关系数：

$R_{x,y}=\frac{\mathrm{cov}\left(\mathrm{xy}\right)}{\sqrt{D\left(x\right)D\left(y\right)}}$

$E\left(x\right)=\frac{1}{N}\underset{i=1}{\overset{N}{\mathrm{\Σ}}}{x}_i,D\left(x\right)\frac{1}{N}\underset{i=1}{\overset{N}{\mathrm{\Σ}}}{(x_i-E\left(x\right))}^2$

$\mathrm{cov}(x,y)=\frac{1}{N}\underset{i=1}{\overset{N}{\mathrm{\Σ}}}(x_i-E\left(x\right))(y_i-E\left(y\right))$

式中，x、y分别表示图像中相邻两个像素的像素值，D(x)表示像素值的均方差，E(x)表示像素值的平均值，cov(x,y)表示相关函数，R_x,y表示相邻两个像素的相关系数。

从图像中选取20000对水平方向相邻像素对，20000对垂直方向相邻像素对和20000对对角方向相邻像素对，定量计算相邻像素的相关系数。

图7描述了原始彩色图像和密文图像的R分量水平方向上相邻像素的相关性。图7(a)为原始图像R分量水平方向上相邻像素的相关性分析图，图7(b)为加密图像R分量水平方向上相邻像素的相关性分析图。按照实施例1中公式分别计算了明文图像和密文图像三基色分量在水平、垂直和对角方向上相邻像素的相关系数，结果如表1所示。从表1中容易看出，原始图像相邻像素高度相关，相关系数接近于1；而加密后的图像在各方向的相邻像素相关系数比明文图像要小得多，其相邻像素相关系数接近于0，相邻像素已基本不相关，明文的统计特征已被扩散到随机的密文中。

表1原始图像和加密图像相邻像素的相关系数

(5)NPCR_R,G,B都大于99％，UACI_R,G,B都大于33％，抗差分攻击能力强。

算法对明文的敏感性越强，抵抗差分攻击的能力也就越强，可以用像素数改变率NPCR(Number of Pixels Change Rate)和归一化像素值平均改变强度UACI(Unified AverageChanging Intensity)度量加密算法对明文的敏感性。计算公式如下：

$\mathrm{NPCR}=\frac{\underset{i,j}{\mathrm{\Σ}}D(i,j)}{M\×N}\×100\%$

$\mathrm{UACI}=\frac{1}{M\×N}\left[\underset{i,j}{\mathrm{\Σ}}\frac{|C_1(i,j)-C_2(i,j)|}{255}\right]\×100\%$

式中，M和N表示图像的行数和列数，C₁表示原来的密文图像，C₂表示改变明文后得到的密文图像，C₁(i,j)表示明文图像在坐标(i,j)处的像素值，C₂(i,j)表示密文图像在坐标(i,j)处的像素值。D表示和密文图像大小一样的矩阵，D(i,j)的值由C₁(i,j)和C₂(i,j)决定。若C₁(i,j)＝C₂(i,j)，那么D(i,j)＝0；若C₁(i,j)≠C₂(i,j)，那么D(i,j)＝1。

本发明中，将原始明文图像的第一个像素值改为226后得到一个新的明文图像，然后将这两个图像用同样的密钥加密形成相应的密文图像C₁和C₂。计算密文图像的NPCR和UACI值如表2所示，可以看到NPCR_R,G,B的值都大于99％，UACI_R,G,B的值都大于33％。这表明，即使对原始图像做微小的变化，通过本算法进行加密后，密文图像也会有明显的差异。因此，本算法可以有效抵抗差分攻击。

表2密文图像的NPCR和UACI值

	R分量	G分量	B分量
				NPCR	0.9963	0.9960	0.9964
UACI	0.3341	0.3352	0.3352

(6)密文图像R、G、B分量的信息熵非常接近理想值8，加密算法安全性好。

信息熵是反映信息随机性的重要度量指标，信息源m的信息熵计算公式如下：

$H\left(m\right)=\underset{i=0}{\overset{2^n-1}{\mathrm{\Σ}}}p\left(m_i\right)\log \frac{1}{p\left(m_i\right)}$

其中，p(m_i)表示符号m_i出现的概率，2ⁿ是信息源m的总状态数。信息加密之后，信息熵的期望值为8。如果加密图像信息熵非常接近8，则表明该密文图像接近随机分布。

对标准LenaRGB图像用本发明算法进行加密，得到密文图像的信息熵为7.9998，密文图像R、G、B分量的信息熵分别为7.9993、7.9993、7.9993，非常接近理想值8，这表明本发明提供的加密算法具有很好的安全性。

实施例2：在本实施例中，采用的编程软件为Matlab R2009a，选取附图8(a)所示的大小为480×512的Fruits彩色图像为实验对象，对该彩色图像加密的过程如下：

1.输入图像大小为480×512的原始彩色图像I₀，用I₀＝imread('Fruits.bmp')读取图像信息。利用SHA-384函数对原始彩色图像I₀进行计算，得到一组384位的哈希值作为密钥，将384位的哈希值从二进制转化为十六进制，得到96个十六进制数，即B C86B B7315F58B6575C E85C C55B3983635F0B B41D0A66088F B4D F9D D8B67DF49E F83B9381441B8B8218E3D A34E D A7677。将哈希值平均分割为3组，每组32个十六进制数，将各组元素分别转化为十进制数，并计算各组元素之和Sum(j)(j＝1,2,3)，通过下面公式计算出x₀(1)＝0.8867、x₀(2)＝0.1836和x₀(3)＝0.8906，作为CML耦合映像格子的初始值：

x₀(j)＝(mod(Sum(j),256))/256,其中j＝1,2,3

2.利用时空混沌系统和一维Logistic混沌系统生成用于置乱的混沌序列，对原始彩色图像I₀进行位(bit)级置乱，得到置乱后大小为480×512的图像I₁，见附图8(b)。

3.利用Logistic量子混沌系统生成用于加密置乱图像I₁的混沌序列，并生成权值矩阵W_q和用于异或操作的序列E_p，对图像I₁的三基色分量的所有像素值，通过神经网络进行并行扩散，得到扩散后图像的三基色分量I₂R、I₂G和I₂B，从而最终得到加密图像I₂，见附图8(c)。

加密过程中采用的混沌系统、加密步骤和相应步骤的参数同实施例1，不再赘述。

图像解密过程与加密过程类似，只需按照与加密过程相逆的顺序进行运算即可恢复出原始彩色图像I₀。解密过程中，各个步骤所用CML耦合映像格子、一维Logistic混沌系统和量子Logistic混沌系统的参数、初始值和其它参数与加密过程中对应相同。当密钥正确时，解密图像见附图8(d)。此外，附图8(e)为参数密钥错误下的解密图像，8(f)为错误图像密钥下的解密图像，从图8(e)和8(f)难以辨认原始图像，可见本发明的图像加密算法具有很好的加密效果。

下面对本发明的图像加密算法进行安全性分析。

(1)密钥空间大，足以抵抗穷举攻击

密钥与实施例1的密钥相同，具体包括：1)系统参数a₀、k₁₀、k₂₀、b₀、r₀、ε₀；2)时空混沌系统初始值x₀(1)、x₀(2)、x₀(3)和Logistic量子混沌系统初始值x(1)₀、x(2)₀、x(3)₀，x(1)′₀、x(2)′₀、x(3)′₀和x(1)″₀、x(2)″₀、x(3)″₀；3)384位的哈希值。在Matlab R2009a环境下，所有数据类型都采用精度为10位的双精度实数，则密钥空间至少为2³⁸⁴×10¹⁸⁰。因此，本发明的加密算法具有足够大的密钥空间，足以抵抗穷举攻击。

(2)密钥敏感性高

对于附图8(c)所示的加密图像，附图8(d)所示为当采用正确密钥时得到的清晰解密图像，可以精确恢复出原始图像。1)保持其它密钥参数不变，当h₀改变+10^-16，进行解密，附图8(e)所示为当h₀＝0.1234567890000001时解密图像；2)保持其它密钥参数不变，将384位的哈希值的第四位由1变0，即图像的哈希值由B C86B B7315F58B6575C E85C C55B3983635F0B B41D0A66088F B4D F9D D8B67D F49E F83B9381441B8B8218E3D A34E D A7677变为A C86B B7315F58B6575C E85C C55B3983635F0B B41D0A66088F B4D F9D D8B67D F49E F83B9381441B8B8218E3D A34E D A7677，用改变后的哈希值进行解密，解密后的图像见附图8(f)。从附图8(e)和8(f)容易看出，即使密钥存在微小差异，解密图像依然是类似于噪声的均匀图像，无法辨认出原始图像的任何信息。由此可见，本发明的加密算法具有高度的密钥敏感性。

(3)密文图像的灰度直方图平滑且均匀，抗统计分析攻击能力强。

图9所示为原始彩色图像及其R、G、B分量的直方图，图10所示为加密图像及其R、G、B分量的直方图。由图可知，原始图像的像素分布很不均匀，而加密图像R、G和B分量的像素呈现均匀分布的特点，加密图像的像素值在[0,255]范围内取值概率均等。由此可见，该加密算法具有良好的抵抗统计分析攻击的能力。

(4)原始图像相邻像素高度相关，加密后图像相邻像素相关系数接近于0，基本不相关。

从图像中选取20000对水平方向相邻像素对，20000对垂直方向相邻像素对和20000对对角方向相邻像素对，定量计算相邻像素的相关系数。

图11描述了原始彩色图像和密文图像的R分量水平方向上相邻像素的相关性。图11(a)为原始图像R分量水平方向上相邻像素的相关性分析图，图11(b)为加密图像R分量水平方向上相邻像素的相关性分析图。按照实施例1中公式分别计算了明文图像和密文图像三基色分量在水平、垂直和对角方向上相邻像素的相关系数，结果如表3所示。从表3中容易看出，原始图像相邻像素高度相关，相关系数接近于1；而加密后的图像在各方向的相邻像素相关系数比明文图像要小得多，其相邻像素相关系数接近于0，相邻像素已基本不相关，明文的统计特征已被扩散到随机的密文中。

表3原始图像和加密图像相邻像素的相关系数

(5)NPCR_R,G,B都大于99％，UACI_R,G,B都大于33％，抗差分攻击能力强。

本发明中，将原始明文图像的第一个像素值改为131后得到一个新的明文图像，然后将这两个图像用同样的密钥加密形成相应的密文图像C₁和C₂。计算密文图像的NPCR和UACI值如表4所示，可以看到NPCR_R,G,B的值都大于99％，UACI_R,G,B的值都大于33％。这表明，即使对原始图像做微小的变化，通过本算法进行加密后，密文图像也会有明显的差异。因此，本算法可以有效抵抗差分攻击。

表4密文图像的NPCR和UACI值

	R分量	G分量	B分量
				NPCR	0.9959	0.9961	0.9962
UACI	0.3352	0.3343	0.3351

(6)密文图像R、G、B分量的信息熵非常接近理想值8，加密算法安全性好。

用本发明算法对实施例2原始彩色图像进行加密，得到密文图像的信息熵为7.9997，密文图像R、G、B分量的信息熵分别为7.9991、7.9992、7.9993，非常接近理想值8，这表明本发明提供的加密算法具有很好的安全性。

由上述实施例1和实施例2可知，本发明提供的加密算法可对M＝N或M≠N的彩色图像进行高安全的加密，在信息加密领域具有极其广阔的应用前景。

上面结合附图对本发明优选的具体实施方式和实施例作了详细说明，但是本发明并不限于上述实施方式和实施例，在本领域技术人员所具备的知识范围内，还可以在不脱离本发明构思的前提下作出各种变化。

Claims (1)

1.一种基于SHA-384函数、时空混沌系统、量子混沌系统和神经网络的彩色图像加密方法，其特征在于包括以下步骤：

(1)输入RGB格式的图像大小为M×N的原始彩色图像I₀；

(2)利用SHA-384函数、时空混沌系统和一维混沌映射生成混沌序列，对所述彩色图像I₀进行位级置乱加密，得到加密图像I₁，其中的时空混沌系统为CML耦合映像格子，其动力学方程为

$\left\{\begin{array}{c}{x}_{n+1}\left(i\right)=(1-\mathrm{\ϵ})f\left(x_n\left(i\right)\right)+\frac{\mathrm{\ϵ}}{2}\×(f\left(x_n(i-1)\right)+f\left(x_n(i+1)\right))\\ f\left(x_n\right)={\mathrm{ax}}_n(1-x_n)\end{array}\right.$

其中的一维混沌映射为一维Logistic混沌映射

x_n+1＝kx_n(1-x_n)，x_n∈(0，1)

其中，n是离散时间坐标，i是格点坐标，并且i＝1，2，...，L；L为格点数，ε∈(0，1)是格点间的耦合强度因子，x_n(i)代表第i个格点在n时间的状态，x_n为Logistic混沌映射的第n次迭代量，系统参数a∈(3.5699456，4]，系统参数k∈(3.5699456，4]，Logistic映射呈现混沌特性；

并且，步骤(2)中利用SHA-384函数、CML耦合映像格子和一维Logistic混沌映射对彩色图像进行位级置乱加密的具体步骤为：

2.1)利用SHA-384函数对所述原始彩色图像I₀进行计算，得到一组384位的哈希值作为密钥，并将384位的哈希值从二进制转化为十六进制，得到96个十六进制数；

2.2)将哈希值互不重叠平均分割为3组，每组32个十六进制数，将各组元素分别转化为十进制数，并计算各组元素之和Sum(j)，其中j＝1，2，3；然后，通过以下公式计算出x₀(1)、x₀(2)和x₀(3)，作为CML耦合映像格子的初始值：

x₀(j)＝(mod(Sum(j)，256))/256，j＝1，2，3

式中，mod(Sum(j)，256)表示返回Sum(j)除以256的余数；

2.3)选定CML耦合映像格子的系统参数ε₀、a₀，在不同的初值x₀(1)、x₀(2)和x₀(3)下产生长度为的三个实值混沌序列，其中M为原始彩色图像I₀的行数，舍弃前面的m个数值以避免有害的影响，得到三个实值混沌序列D₁、D₂和D₃；

2.4)对D₁、D₂和D₃的原子序列分别按照升序重新排列，得到新的子序列，将原子序列中每个元素所在位置序号替换新的子序列中的对应元素，最终得到长度为M的三个置乱序列TM、TN、TP：

$\left\{\begin{array}{c}\mathrm{TM}=\{{\mathrm{TM}}_1,{\mathrm{TM}}_2,...,{\mathrm{TM}}_M\}\\ \mathrm{TN}=\{{\mathrm{TN}}_1,{\mathrm{TN}}_2,...,{\mathrm{TN}}_M\}\\ \mathrm{TP}=\{{\mathrm{TP}}_1,{\mathrm{TP}}_2,...,{\mathrm{TP}}_M\}\end{array}\right.$

并且，这三个序列中每个元素的元素值代表该位置上的数在所有元素中的位置；

2.5)选取系统参数k₁₀和初始值x₁₀，迭代求解一维Logistic混沌系统得到长度为的实值混沌序列，其中N为原始彩色图像I₀的列数，舍弃前面的m₁个数值，得到实值混沌序列Z₀，并将混沌序列Z₀拆分为三个大小为4N的子序列Z₁、Z₂和Z₃；

2.6)将混沌序列Z₀、Z₁、Z₂和Z₃的原子序列分别按照升序重新排列，得到新的子序列，同时将原子序列中每个元素所在位置序号替换新的子序列中的对应元素，最终分别得到长度为12N的置乱序列IN和长度均为4N的置乱序列INX，INY和INZ：

$\left\{\begin{array}{c}\mathrm{IN}=\{{\mathrm{IN}}_1,{\mathrm{IN}}_2,...,{\mathrm{IN}}_{12N}\}\\ \mathrm{INX}=\{{\mathrm{INX}}_1,{\mathrm{INX}}_2,...,{\mathrm{INX}}_{4N}\}\\ \mathrm{INY}=\{{\mathrm{INY}}_1,{\mathrm{INY}}_2,...,{\mathrm{INY}}_{4N}\}\\ \mathrm{INZ}=\{{\mathrm{INZ}}_1,{\mathrm{INZ}}_2,...,{\mathrm{INZ}}_{4N}\}\end{array}\right.$

并且，这四个序列中每个元素的元素值代表该位置上的数在所有元素中的位置；

2.7)选取参数k₂₀和初始值x₂₀，迭代求解一维Logistic混沌系统得到长度为的实值混沌序列，舍弃掉前面的m₂个数值，得到实值序列H₀；

2.8)将H₀的原子序列按升序重新排列，得到新的子序列，同时将原子序列中每个元素所在位置序号替换新的子序列中的对应元素，最终得到长度为3M的置乱序列TH＝{TH₁，TH₂，...，TH_3M}，并且序列中每个元素的元素值代表该位置上的数在所有元素中的位置；

2.9)分离彩色明文图像I₀的R、G、B三基色分量得到三个大小为M×N的矩阵图像I₀R、I₀G和I₀B，把I₀R图像中的像素值从十进制转化为二进制，得到8个位级图像Rpic₁至Rpic₈，其中每个图像的大小为M×N，然后提取出高四位的四个矩阵Rpic₈、Rpic₇、Rpic₆和Rpic₅，并将图像Rpic₈、Rpic₇、Rpic₆和Rpic₅按照顺序从左到右横向排列构成矩阵R^H＝[Rpic₈，Rpic₇，Rpic₆，Rpic₅]，其中矩阵R^H的大小为M×4N，并保留低四位的Rpic₄、Rpic₃、Rpic₂和Rpic₁四个矩阵，每个矩阵大小为M×N；

2.10)依照与步骤2.9)相同的方法，变换I₀G图像，得到它的8个大小为M×N的位级图像Gpic₁至Gpic₈，提取出高四位矩阵重组得到新的矩阵G^H＝[Gpic₈，Gpic₇，Gpic₆，Gpic₅]，G^H大小为M×4N，并保留Gpic₁至Gpic₄四个矩阵，每个矩阵大小为M×N；变换I₀B图像，得到它的8个大小为M×N的位级图像Bpic₁至Bpic₈，提取出高四位矩阵重组得到矩阵B^H＝[Bpic₈，Bpic₇，Bpic₆，Bpic₅]，B^H大小为M×4N，并保留Bpic₁至Bpic₄四个矩阵，每个矩阵大小为M×N；

2.11)将图像大小为M×4N的R^H、G^H和B^H三个图像从左到右横向排列构成矩阵X₁，大小为M×12N，对图像X₁进行列方向行置乱操作，具体为：对于X₁的第w列，其中1≤w≤12N，当mod(w，3)＝0时，则按置乱序列TM＝{TM₁，TM₂，...，TM_M}重新排列第w列的所有元素，即移动第w列中的第TM₁行元素到第一行，第TM₂行元素到第二行，直至所有元素全部被置乱；当mod(w，3)＝1时，则按置乱序列TN＝{TN₁，TN₂，...，TN_M}重新排列第w列的所有元素，即移动第w列中的第TN₁行元素到第一行，第TN₂行元素到第二行，直至所有元素全部被置乱；当mod(w，3)＝2时，则按置乱序列TP＝{TP₁，TP₂，...，TP_M}重新排列第w列的所有元素，即移动第w列中的第TP₁行元素到第一行，第TP₂行元素到第二行，直至所有元素全部被置乱；以此类推，直到X₁中的每一列的所有元素均被置乱，得到大小为M×12N的图像矩阵X₂；

2.12)根据置乱序列IN＝{IN₁，IN₂，...，IN_12N}对二进制图像X₂进行整体列置乱，即将X₂的第IN₁列移动到第一列，第IN₂列移动到第二列，第IN_n列元素移到第n列，以此类推，直到X₂中的每一列都被置乱，从而得到置乱后大小为M×12N的图像X₃；

2.13)把图像X₃从左到右进行分割，分割为三个大小为M×4N的图像R^H1、G^H1和B^H1，将R^H1、G^H1和B^H1三个图像从上到下纵向排列重组得到大小为3M×4N的图像X₄，然后对X₄进行行方向列置乱操作，具体为：对于X₄的第v行，其中1≤v≤3M，当mod(v，3)＝0时，则按置乱序列INX＝{INX₁，INX₂，...，INX_4N}重新排列第v行的所有元素，即移动第v行中的第INX₁列元素到第一列，第INX₂列元素到第二列，直至所有元素全部被置乱；当mod(v，3)＝1时，则按置乱序列INY＝{INY₁，INY₂，...，INY_4N}重新排列第v行的所有元素，即移动第v行中的第INY₁列元素到第一列，第INY₂列元素到第二列，直至所有元素全部被置乱；当mod(v，3)＝2时，则按置乱序列INZ＝{INZ₁，INZ₂，...，INZ_4N}重新排列第v行的所有元素，即移动第v行中的第INZ₁列元素到第一列，第INZ₂列元素到第二列，直至所有元素全部被置乱；以此类推，直到X₄中的每一行的所有元素都被置乱，得到大小为3M×4N的图像矩阵X₅；

2.14)利用置乱序列TH＝{TH₁，TH₂，...，TH_3M}对X₅进行整体行置乱，即将X₅的第TH₁行移动到第一行，第TH₂行移动到第二行，第TH_n行元素移到第n行，以此类推，直到X₅中的每一行都被置乱，得到置乱后大小为3M×4N的图像X₆；

2.15)将图像矩阵X₆从上到下进行分割，分割成3个大小为M×4N的矩阵R^H2、G^H2和B^H2，将图像R^H2与步骤2.10)中保留的Bpic₄至Bpic₁四个矩阵从左到右横向排列，组成置乱后的二值图像R′，把像素值从二进制转换成十进制，得到大小为M×N的图像R″；将图像G^H2与步骤2.9)中保留的Rpic₄至Rpic₁四个矩阵从左到右横向排列，组成置乱后的二值图像G′，把像素值从二进制转换成十进制，得到大小为M×N的图像G″；将图像B^H2与步骤2.10)中保留的Gpic₄-Gpic₁四个矩阵从左到右横向排列，组成置乱后的二值图像B′，把像素值从二进制转换成十进制，得到大小为M×N的图像B″；

2.16)将图像R″、G″和B″进行合并，即I₁(1：M，1：N，1)＝R″(1：M，1：N)，I₁(1：M，1：N，2)＝G″(1：M，1：N)，I₁(1：M，1：N，3)＝B″(1：M，1：N)，从而得到置乱后的图像I₁；

(3)利用量子混沌系统生成混沌序列，并结合神经网络对所述加密图像I1进行扩散加密处理，得到最终的密文图像I₂，所述量子混沌系统为Logistic量子混沌系统，其动力学方程为

$\left\{\begin{array}{c}{x\left(1\right)}_{n+1}=r(x{\left(1\right)}_n-{\left|x{\left(1\right)}_n\right|}^2)-r*x{\left(2\right)}_n\\ {x\left(2\right)}_{n+1}=-x{\left(2\right)}_n*e^{-2b}+e^{-b}*r*[(2-x{\left(1\right)}_n-x{\left(1\right)}_n^{*})*x{\left(2\right)}_n-x{\left(1\right)}_n*{x\left(3\right)}_n^{*}-x{\left(1\right)}_n^{*}*x{\left(3\right)}_n]\\ x{\left(3\right)}_{n+1}=-x{\left(3\right)}_n*e^{-2b}+e^{-b}*r*[2*(1-x{\left(1\right)}_n^{*})*x{\left(3\right)}_n-2*x{\left(1\right)}_{n}x{\left(2\right)}_n-x{\left(1\right)}_n]\end{array}\right.$

其中，参数r∈(3.74，4.00)，参数b≥3.5，x(1)_n、x(2)_n及x(3)_n为系统的状态，且x(1)_n∈(0，1)，x(2)_n∈(0，0.2469)，x(3)_n∈(0，0.2469)，和分别为x(1)_n和x(3)_n的复共轭；

并且，利用Logistic量子混沌系统对图像I₁进行加密的具体步骤为：

3.1)选取参数r₀、b₀，在三组不同初始值x(1)₀、x(2)₀、x(3)₀，x(1)′₀、x(2)′₀、x(3)′₀和x(1)″₀、x(2)″₀、x(3)″₀下，迭代Logistic量子混沌映射得到长度为的9个实值混沌序列，舍弃掉前面的m₃个数值，得到实值序列K1、K2、K3、K4、K5、K6、K7、K8、K9；

3.2)将经过步骤2.15)后得到的大小为M×N的图像R″、G″和B″转换为大小为1×MN的实值序列R1、G1和B1；设定神经网络输入为A_z＝[R1(z)；G1(z)；B1(z)]，其中R1(z)、G1(z)和B1(z)为实值序列R1、G1和B1的第z个元素，A_z为神经网络的第z个输入，并且z＝1，2，...，MN；对序列K1、K2、K3、K4、K5、K6、K7、K8、K9进行运算，得到神经网络的权值矩阵W_q为

$W_q=0.5\left[\begin{array}{ccc}K1\left(q\right)& K4\left(q\right)& K7\left(q\right)\\ K2\left(q\right)& K5\left(q\right)& K8\left(q\right)\\ K3\left(q\right)& K6\left(q\right)& K9\left(q\right)\end{array}\right]+0.5\left[\begin{array}{ccc}1& 1& 1\\ 1& 1& 1\\ 1& 1& 1\end{array}\right]$

其中，q代表实值序列K1、K2、K3、K4、K5、K6、K7、K8、K9中的第q个元素，且q＝1，2，...，MN；

3.3)利用权值矩阵W_q对神经网络的输入A_z按照下式处理，得到神经网络的输出Y₁，其中它的第p个元素Y_1p为：

Y_1p＝W_q*A_z+B_p，其中p＝1，2，...，MN，并且p＝q＝z

式中，神经网络的阀值量B_p为全零矩阵，处理后得到输出量为Y_1p＝[R1¹(p)；G1¹(p)；B1¹(p)]，R1¹(p)、G1¹(p)和B1¹(p)分别为处理后的图像第p个像素的R、G和B分量的像素值；

3.4)设置参数n₁和n₂，对于经步骤3.3)后所得到的矩阵Y₁，按照下式将其所有元素数值都转换到0到255之间，得到新的矩阵Y₂，同时得到由Y₂中各元素的整数部分所组成的矩阵Y₃和由Y₂中各元素的小数部分所组成的矩阵Y₄：

$\left\{\begin{array}{c}{Y}_{2p}=n_1\×Y_{1p}+n_2\\ Y_{3p}=\mathrm{floor}\left(Y_{2p}\right)\\ Y_{4p}=Y_{2p}-Y_{3p}\end{array}\right.,p=\mathrm{1,2},...,\mathrm{MN}$

其中，floor(s)函数表示返回距离s最近的小于或等于s的整数；转换后得到Y_2p＝[R1²(p)；G1²(p)；B1²(p)]，整数部分为Y_3p＝[R1³(p)；G1³(p)；B1³(p)]，小数部分为Y_4p＝[R1⁴(p)；G1⁴(p)；B1⁴(p)]，Y_1p、Y_2p、Y_3p、Y_4p分别为Y₁、Y₂、Y₃、Y₄的第p个元素，R1²(p)、G1²(p)、B1²(p)分别为转换后的图像第p个像素的R、G和B分量的像素值，R1³(p)、G1³(p)、B1³(p)分别为转换后的图像第p个像素的R、G和B分量的像素值的整数部分，R1⁴(p)、G1⁴(p)、B1⁴(p)分别为转换后的图像第p个像素的R、G和B分量的像素值的小数部分；

3.5)选取混沌序列K1、K4、K7，每个序列大小为1×MN，利用下式对混沌序列K1、K4、K7中的每个元素都进行处理，把三个实值序列的每个元素数值都转换到0到255之间，得到改进的实值序列K1¹、K4¹和K7¹，其中q＝1，2，...，MN；

$\left\{\begin{array}{c}{K1}^1\left(q\right)=\mathrm{mod}(\mathrm{floor}(K1\left(q\right)*10^14),256)\\ {K4}^1\left(q\right)=\mathrm{mod}(\mathrm{floor}(K4\left(q\right)*10^14),256)\\ {K7}^1\left(q\right)=\mathrm{mod}(\mathrm{floor}(K7\left(q\right)*10^14),256)\end{array}\right.$

3.6)将K1¹、K4¹和K7¹按照顺序从上到下进行组合，得到大小为3×MN的矩阵E，对矩阵Y₃中的各个元素按照下式进行加密操作，得到新的矩阵Y₅，即矩阵Y₅中的第p个元素Y_5p＝[R1⁵(p)；G1⁵(p)；B1⁵(p)]，其中R1⁵(p)、G1⁵(p)和B1⁵(p)分别为加密操作后的图像第p个像素的R、G和B分量的像素值的整数部分：

$Y_{5p}=Y_{3p}\⊕E_p,p=\mathrm{1,2},...,\mathrm{MN}$

式中，“”为异或运算操作符，Y_3p、E_p、Y_5p分别是Y₃、E、Y₅的第p个元素，E_p＝[K1¹(p)；K4¹(p)；K7¹(p)]；

3.7)利用下式对Y₅中的每个元素都进行处理，得到矩阵C：

C_p＝f(Y_5p，Y_4p)＝Y_5p+Y_4p，p＝1，2，...，MN

其中神经网络的激活函数f为加法运算，C_p是C的第p个元素，同时神经网络的最终输出C_p为图像的第p个像素的密文像素值，最终的加密结果C_p＝[R1′(p)；G1′(p)；B1′(p)]，其中R1′(p)为加密后的第p个像素的红色分量，G1′(p)为加密后的第p个像素的绿色分量，B1′(p)为加密后的第p个像素的蓝色分量；

3.8)将经步骤3.7)所得到的所有像素的红色分量、绿色分量和蓝色分量，按行排列分别转换为大小为M×N的矩阵，得到扩散后图像的三基色分量I₂R、I₂G和I₂B，从而最终得到加密图像I₂。