基于加取模运算的扩散处理的图像加密、图像置乱（matlab）

基于加取模运算的扩散处理是一种常用的图像加密和图像置乱方法。其基本思想是通过将图像的像素值与密钥进行加取模运算，从而实现图像的扩散和置乱。

具体步骤如下：

1. 密钥生成：生成一个与原始图像大小相同的密钥矩阵，密钥矩阵中的元素可以是随机数或者通过某种算法生成的固定值。

2. 图像加密：将原始图像的像素值与密钥矩阵进行加取模运算，得到加密后的图像。加取模运算可以使用模运算或者异或运算。

3. 图像扩散：通过对加密后的图像进行像素位置的调整，实现图像的扩散。常用的方法有置乱矩阵、置乱序列等。

4. 图像解密：将加密后的图像与密钥矩阵进行逆运算，即再次进行加取模运算，得到解密后的图像。

clc;clear;%基于加取模运算的扩散处理
P=imread('8888.jpeg');P=rgb2gray(P);
iptsetpref('imshowborder','tight');
figure(1);imshow(P);
[M,N]=size(P);P=double(P);

n = 2 * M * N;
h=0.002;t=800;a=10;b=8/3;c=28;r=-1;x0=1.1;y0=2.2;z0=3.3;w0=4.4;
s=zeros(1,n);
for i=1:n+t
    K11=a*(y0-x0)+w0;K12=a*(y0-(x0+K11*h/2))+w0;
    K13=a*(y0-(x0+K12*h/2))+w0;K14=a*(y0-(x0+K13*h))+w0;
    x1=x0+(K11+K12+K13+K14)*h/6;
    K21=c*x1-y0-x1*z0;K22=c*x1-(y0+K21*h/2)-x1*z0;
    K23=c*x1-(y0+K22*h/2)-x1*z0;K24=c*x1-(y0+K23*h)-x1*z0;
    y1=y0+(K21+K22+K23+K24)*h/6;
    K31=x1*y1-b*z0;K32=x1*y1-b*(z0+K31*h/2);
    K33=x1*y1-b*(z0++K32*h/2);K34=x1*y1-b*(z0+K33*h);
    z1=z0+(K31+K32+K33+K34)*h/6;
    K41=-y1*z1+r*w0;K42=-y1*z1+r*(w0+K41*h/2);
    K43=-y1*z1+r*(w0+K42*h/2);K44=-y1*z1+r*(w0+K43*h);
    w1=w0+(K41+K42+K43+K44)*h/6;
    
    x0=x1;y0=y1;z0=z1;w0=w1;
    if i>t
        s(i-t)=x1;
        if mod((i-t),3000)==0
            x0=x0+h*sin(y0);
        end
    end
end

S=mod(floor(s*pow2(16)),256);
S1=S(1:M*N);S2=S(M*N+1:2*M*N);B=zeros(M,N);C=zeros(M,N);
tic;A=P(:);B0=0;B(1)=mod(B0+S1(1)+A(1),256);
for i=2:M*N
    B(i)=mod(B(i-1)+S1(i)+A(1),256);
end
C0=0;C(M*N)=mod(C0+S2(M*N)+B(M*N),256);
for i=M*N-1:-1:1
    C(i)=mod(C(i+1)+S2(i)+B(i),256);
end
C=reshape(C,M,N);toc;
figure(2);imshow(uint8(C));

A = C(:);D=zeros(M,N);E=zeros(M,N);
D0 = 0; D(M * N)=mod(256 * 2 + C(M * N) - D0 - S2(M * N),256);
for i = M * N -1:-1:1
    D(i)=mod(256 * 2+C(i)-C(i + 1)-S2(i),256);
end
E0=0;E(1)=mod(256 * 2 + D(1) - E0 - S1(1),256);
for i = 2 : M * N
    E(i)=mod(256 * 2 + D(i) - D(i - 1) - S1(i),256);
end
E=reshape(E,M,N);figure(3);imshow(uint8(E));

基于加取模运算的扩散处理具有较好的安全性和随机性，可以有效保护图像的机密性。同时，由于加取模运算是一种非线性运算，能够使得图像的像素值在加密和解密过程中发生较大的变化，增加了破解的难度。