多幅图像混沌加密算法实现：基于Zigzag置乱的三维图像立方体加密

这段代码是对多幅图像进行混沌加密的过程。

首先，将四幅二维图像读入并存储为一个三维矩阵 I，然后对每幅图像进行哈希操作，将哈希向量归一化后作为混沌系统的初值。同时对 R 图像进行哈希操作，并对混沌系统输出的结果进行取模操作得到 X、Y、Z、H 四个向量。

接下来，将每幅图像按照分块大小 t 进行分块，并对每个分块按照 X 对应的序号进行DNA编码，对 R 图像按照 Y 对应的序号进行DNA编码，然后对这两个编码好的块按 Z 对应的序号进行DNA运算，运算结果再和前一块按 Z 对应的序号再一次进行运算，称为扩散。将每一块合并成完整的图 Q。

然后对 Q 进行二次置乱，其中密钥为 G 通道和 B 通道的平均灰度值，通过混沌系统得到 ppx 和 ppy 两个向量，将 Q 的每一行按 ppx 的降序排列，每一列按 ppy 的降序排列，完成二次置乱。

最后得到加密后的图像 Q_jiami，其中 Q_jiami(:,:,1) 表示第一幅图像的加密结果，以此类推。

Zigzag 对多幅图像形成的三维图像立方体的置乱作用是将三维图像中的每个二维图像进行置乱，使得加密更加安全。

具体步骤如下：

读取图像并存储为三维矩阵:

I = [];
I1 = imread('scenery1.png','png');
I1 = rgb2gray(I1);

I2 = imread('scenery2.tif','tif');
I2 = rgb2gray(I2);
I3 = imread('scenery3.tif','tif');
I3 = rgb2gray(I3);

I4 = imread('scenery4.tif','tif');

I(:,:,1) = I1;
I(:,:,2) = I2;
I(:,:,3) = I3;
I(:,:,4) = I4;

对图像进行哈希操作并获取混沌系统的初值:

[M,N]=size(I1);

// 对每幅图像进行哈希操作
haxi_dec1 = haxi(I1);
haxi_dec2 = haxi(I2);
haxi_dec3 = haxi(I3);
haxi_dec4 = haxi(I4);

// 将哈希向量合并为一个矩阵
haxi = [haxi_dec1,haxi_dec2,haxi_dec3,haxi_dec4];

// 获取哈希向量的最大值和最小值
haxi_max = max(haxi);
haxi_min = min(haxi);

// 对哈希向量进行归一化
haxi_norm = haxi/haxi_max;

// 获取混沌系统的初值
X0=round(haxi_norm(1)*10^4)/10^4;
Y0=round(haxi_norm(2)*10^4)/10^4;
Z0=round(haxi_norm(3)*10^4)/10^4;
H0=round(haxi_norm(4)*10^4)/10^4;

对图像进行分块DNA编码和运算:

// 计算每个分块的大小
r=(M/t)*(N/t);

// 使用混沌系统生成密钥向量
A=chen_output(X0,Y0,Z0,H0,r);
X=A(:,1);
X=X(3002:length(X));
Y=A(:,2);
Y=Y(3002:length(Y));
Z=A(:,3);
Z=Z(3002:length(Z));
H=A(:,4);
H=H(3002:length(H));

// 对图像进行分块
I_Zigzag = [];
I1_Zigzag = reshape(Zigzag(I1),512,512);
I2_Zigzag = reshape(Zigzag(I2),512,512);
I3_Zigzag = reshape(Zigzag(I3),512,512);
I4_Zigzag = reshape(Zigzag(I4),512,512);
I_Zigzag(:,:,1) = I1_Zigzag;
I_Zigzag(:,:,2) = I2_Zigzag;
I_Zigzag(:,:,3) = I3_Zigzag;
I_Zigzag(:,:,4) = I4_Zigzag;

// 对每个分块进行DNA编码和运算
for i=1:r
    Q1_1=DNA_bian(fenkuai(t,I1,i),X(i));
    Q1_2=DNA_bian(fenkuai(t,I2,i),X(i));
    Q1_3=DNA_bian(fenkuai(t,I3,i),X(i));
    Q1_4=DNA_bian(fenkuai(t,I4,i),X(i));
    
    Q2=DNA_bian(fenkuai(t,R,i),Y(i));
    
    Q3_1=DNA_yunsuan(Q1_1,Q2,Z(i));
    Q4_1=DNA_yunsuan(Q3_1,Q_last_1,Z(i));
    Q_last_1=Q4_1;
    
    Q3_2=DNA_yunsuan(Q1_2,Q2,Z(i));
    Q4_2=DNA_yunsuan(Q3_2,Q_last_2,Z(i));
    Q_last_2=Q4_2;
    
    Q3_3=DNA_yunsuan(Q1_3,Q2,Z(i));
    Q4_3=DNA_yunsuan(Q3_3,Q_last_3,Z(i));
    Q_last_3=Q4_3;
    
    Q3_4=DNA_yunsuan(Q1_4,Q2,Z(i));
    Q4_4=DNA_yunsuan(Q3_4,Q_last_4,Z(i));
    Q_last_4=Q4_4;
    
    // 将每一块合并成完整的图
    xx=floor(i/e)+1;
    yy=mod(i,e);
    if yy==0
        xx=xx-1;
        yy=e;
    end
    Q_1((xx-1)*t+1:xx*t,(yy-1)*t+1:yy*t)=DNA_jie(Q4_1,H(i));
    Q_2((xx-1)*t+1:xx*t,(yy-1)*t+1:yy*t)=DNA_jie(Q4_2,H(i));
    Q_3((xx-1)*t+1:xx*t,(yy-1)*t+1:yy*t)=DNA_jie(Q4_3,H(i));
    Q_4((xx-1)*t+1:xx*t,(yy-1)*t+1:yy*t)=DNA_jie(Q4_4,H(i));
end

对加密后的图像进行二次置乱:

// 获取密钥
xx0=sum(I2(:))/(255*SUM);
xx0=floor(xx0*10^4)/10^4;
xx1=sum(I3(:))/(255*SUM);
xx1=floor(xx1*10^4)/10^4;

// 使用混沌系统生成密钥向量
for i=1:M+999
    ppx(i+1)=u*ppx(i)*(1-ppx(i));
end
for i=1:N+999
    ppy(i+1)=u*ppy(i)*(1-ppy(i));
end

// 对Q进行二次置乱
for i=1:M
    temp = Q_1(i,:);
    Q_1(i,:) = Q_1(Ux(i),:); 
    Q_1(Ux(i),:) = temp;
    
    temp = Q_2(i,:);
    Q_2(i,:) = Q_2(Ux(i),:); 
    Q_2(Ux(i),:) = temp;
    
    temp = Q_3(i,:);
    Q_3(i,:) = Q_3(Ux(i),:); 
    Q_3(Ux(i),:) = temp;
    
    temp = Q_4(i,:);
    Q_4(i,:) = Q_4(Ux(i),:); 
    Q_4(Ux(i),:) = temp;
end

for i=1:N
    temp = Q_1(:,i);
    Q_1(:,i) = Q_1(:,Uy(i)); 
    Q_1(:,Uy(i)) = temp;
    
    temp = Q_2(:,i);
    Q_2(:,i) = Q_2(:,Uy(i)); 
    Q_2(:,Uy(i)) = temp;
    
    temp = Q_3(:,i);
    Q_3(:,i) = Q_3(:,Uy(i)); 
    Q_3(:,Uy(i)) = temp;
    
    temp = Q_4(:,i);
    Q_4(:,i) = Q_4(:,Uy(i)); 
    Q_4(:,Uy(i)) = temp;
end

将加密后的图像存储为三维矩阵:

Q_jiami(:,:,1) = Q_1;
Q_jiami(:,:,2) = Q_2;
Q_jiami(:,:,3) = Q_3;
Q_jiami(:,:,4) = Q_4;

Zigzag 置乱的作用是将三维图像中的每个二维图像进行置乱，使得加密更加安全。例如，对于第一幅图像，Zigzag 置乱会将图像像素按照Z字形进行排列，然后按照混沌系统的密钥进行置乱，最终得到加密后的图像。

这个过程可以重复进行多次，以提高加密的安全性。