多混沌图像加密方案，结合Logistic映射和超混沌Chen系统，实现像素置乱 + 灰度扩散的双重加密。代码完全基于MATLAB基础函数，无需额外工具箱。
一、加密算法流程
明文图像
↓
Step1: 生成混沌序列（Logistic + Chen超混沌）
↓
Step2: 像素位置置乱（Arnold猫映射 + Logistic排序）
↓
Step3: 像素灰度扩散（Chen系统生成密钥流异或）
↓
密文图像二、混沌系统定义
2.1 Logistic映射（一维混沌）
xn+1=μxn(1−xn),μ∈(3.57,4\]x_{n+1} = \\mu x_n (1-x_n), \\quad \\mu \\in (3.57, 4\]xn+1=μxn(1−xn),μ∈(3.57,4\]
2.2 超混沌Chen系统（四维）
{x˙=a(y−x)+wy˙=dx−xz+cyz˙=xy−bzw˙=yz+rw\begin{cases} \dot{x} = a(y-x) + w \\ \dot{y} = dx - xz + cy \\ \dot{z} = xy - bz \\ \dot{w} = yz + rw \end{cases}⎩ ⎨ ⎧x˙=a(y−x)+wy˙=dx−xz+cyz˙=xy−bzw˙=yz+rw
典型参数：(a=35, b=3, c=12, d=7, r=0.58) 时系统处于超混沌状态。
三、MATLAB代码实现
3.1 主加密函数 chaotic_image_encrypt.m
matlab
function cipher_img = chaotic_image_encrypt(plain_img, keys)
% 多混沌图像加密
% 输入：
% plain_img - 明文图像（uint8，灰度或RGB）
% keys - 密钥结构体，包含：
% keys.logistic_mu - Logistic参数 μ ∈ (3.57,4]
% keys.logistic_x0 - Logistic初值 x0 ∈ (0,1)
% keys.chen_init - Chen系统初值 [x0,y0,z0,w0]
% keys.arnold_iter - Arnold置乱迭代次数
% 输出：
% cipher_img - 密文图像
% 参数检查
if nargin < 2
keys = struct();
keys.logistic_mu = 3.99;
keys.logistic_x0 = 0.315;
keys.chen_init = [0.325, -0.625, 0.825, 0.925];
keys.arnold_iter = 3;
end
% 转换为double并归一化到[0,255]
if isinteger(plain_img)
plain_img = double(plain_img);
end
% 获取图像尺寸
[M, N, C] = size(plain_img);
total_pixels = M * N;
% 如果是彩色图像，分别处理每个通道
if C == 3
cipher_img = zeros(M, N, 3, 'uint8');
for ch = 1:3
cipher_img(:,:,ch) = encrypt_channel(plain_img(:,:,ch), keys, M, N);
end
else
cipher_img = encrypt_channel(plain_img, keys, M, N);
end
cipher_img = uint8(cipher_img);
end
function ch_out = encrypt_channel(ch_in, keys, M, N)
% 单通道加密
total = M * N;
% Step1: 生成混沌序列
% 1.1 Logistic序列（用于置乱索引）
logistic_seq = logistic_map(keys.logistic_mu, keys.logistic_x0, total);
% 1.2 Chen超混沌序列（用于扩散密钥流）
chen_seq = chen_hyperchaos(keys.chen_init, total);
% Step2: 像素位置置乱（Arnold猫映射 + Logistic排序）
% 2.1 Arnold猫映射置乱
arnold_iter = keys.arnold_iter;
scrambled = arnold_cat_map(ch_in, M, N, arnold_iter);
% 2.2 Logistic排序置乱（对一维序列排序）
scrambled_vec = scrambled(:);
[~, sort_idx] = sort(logistic_seq);
scrambled_vec = scrambled_vec(sort_idx);
% Step3: 灰度扩散（Chen序列异或）
% 将Chen序列映射到[0,255]
key_stream = mod(floor(abs(chen_seq) * 1e10), 256);
% 异或加密
encrypted_vec = bitxor(uint8(scrambled_vec), uint8(key_stream));
% 重组为图像
ch_out = reshape(encrypted_vec, M, N);
end3.2 Logistic映射函数 logistic_map.m
matlab
function seq = logistic_map(mu, x0, len)
% 生成Logistic混沌序列
seq = zeros(len, 1);
x = x0;
for i = 1:len
x = mu * x * (1 - x);
seq(i) = x;
end
end3.3 超混沌Chen系统函数 chen_hyperchaos.m
matlab
function seq = chen_hyperchaos(init, len)
% 生成超混沌Chen系统序列（四维）
% 使用四阶Runge-Kutta离散化
% 系统参数
a = 35; b = 3; c = 12; d = 7; r = 0.58;
dt = 0.001;
% 初始化
x = init(1); y = init(2); z = init(3); w = init(4);
seq = zeros(len, 4);
for i = 1:len
% RK4步进
k1x = a*(y-x) + w;
k1y = d*x - x*z + c*y;
k1z = x*y - b*z;
k1w = y*z + r*w;
k2x = a*((y+0.5*k1y*dt)-(x+0.5*k1x*dt)) + (w+0.5*k1w*dt);
k2y = d*(x+0.5*k1x*dt) - (x+0.5*k1x*dt)*(z+0.5*k1z*dt) + c*(y+0.5*k1y*dt);
k2z = (x+0.5*k1x*dt)*(y+0.5*k1y*dt) - b*(z+0.5*k1z*dt);
k2w = (y+0.5*k1y*dt)*(z+0.5*k1z*dt) + r*(w+0.5*k1w*dt);
k3x = a*((y+0.5*k2y*dt)-(x+0.5*k2x*dt)) + (w+0.5*k2w*dt);
k3y = d*(x+0.5*k2x*dt) - (x+0.5*k2x*dt)*(z+0.5*k2z*dt) + c*(y+0.5*k2y*dt);
k3z = (x+0.5*k2x*dt)*(y+0.5*k2y*dt) - b*(z+0.5*k2z*dt);
k3w = (y+0.5*k2y*dt)*(z+0.5*k2z*dt) + r*(w+0.5*k2w*dt);
k4x = a*((y+k3y*dt)-(x+k3x*dt)) + (w+k3w*dt);
k4y = d*(x+k3x*dt) - (x+k3x*dt)*(z+k3z*dt) + c*(y+k3y*dt);
k4z = (x+k3x*dt)*(y+k3y*dt) - b*(z+k3z*dt);
k4w = (y+k3y*dt)*(z+k3z*dt) + r*(w+k3w*dt);
x = x + (k1x + 2*k2x + 2*k3x + k4x)*dt/6;
y = y + (k1y + 2*k2y + 2*k3y + k4y)*dt/6;
z = z + (k1z + 2*k2z + 2*k3z + k4z)*dt/6;
w = w + (k1w + 2*k2w + 2*k3w + k4w)*dt/6;
seq(i,:) = [x, y, z, w];
end
end3.4 Arnold猫映射置乱函数 arnold_cat_map.m
matlab
function scrambled = arnold_cat_map(img, M, N, iter)
% Arnold猫映射置乱
% 变换矩阵：[[1,1],[1,2]] 模 N
% 适用于方形图像（M=N），若非方形则先填充或分块处理
if M ~= N
% 非方形图像：先填充为方形
max_dim = max(M, N);
padded = zeros(max_dim, max_dim);
padded(1:M, 1:N) = img;
M = max_dim; N = max_dim;
else
padded = img;
end
scrambled = padded;
for k = 1:iter
temp = zeros(M, N);
for i = 1:M
for j = 1:N
new_i = mod(i + j - 2, M) + 1;
new_j = mod(i + 2*j - 3, N) + 1;
temp(new_i, new_j) = scrambled(i, j);
end
end
scrambled = temp;
end
% 裁剪回原始尺寸
scrambled = scrambled(1:size(img,1), 1:size(img,2));
end3.5 解密函数 chaotic_image_decrypt.m
matlab
function plain_img = chaotic_image_decrypt(cipher_img, keys)
% 多混沌图像解密（逆过程）
% 注意：解密需使用与加密完全相同的密钥和混沌序列
if isinteger(cipher_img)
cipher_img = double(cipher_img);
end
[M, N, C] = size(cipher_img);
total = M * N;
if C == 3
plain_img = zeros(M, N, 3, 'uint8');
for ch = 1:3
plain_img(:,:,ch) = decrypt_channel(cipher_img(:,:,ch), keys, M, N);
end
else
plain_img = decrypt_channel(cipher_img, keys, M, N);
end
plain_img = uint8(plain_img);
end
function ch_out = decrypt_channel(ch_in, keys, M, N)
total = M * N;
% 生成与加密完全相同的混沌序列
logistic_seq = logistic_map(keys.logistic_mu, keys.logistic_x0, total);
chen_seq = chen_hyperchaos(keys.chen_init, total);
% Step1: 逆扩散（异或）
key_stream = mod(floor(abs(chen_seq) * 1e10), 256);
vec_in = ch_in(:);
vec_xor = bitxor(uint8(vec_in), uint8(key_stream));
% Step2: 逆置乱（Logistic排序逆变换）
[~, sort_idx] = sort(logistic_seq);
% 恢复原始顺序：sort_idx给出了加密时的排列，逆排列为 inv_sort
inv_sort = zeros(total,1);
inv_sort(sort_idx) = (1:total)';
vec_unscrambled = vec_xor(inv_sort);
% Step3: 逆Arnold猫映射
temp = reshape(vec_unscrambled, M, N);
arnold_iter = keys.arnold_iter;
% 逆映射需要反向迭代，但Arnold映射是周期性的，可用正向迭代 (period - iter) 代替
% 对于方形图像，Arnold映射周期为 period = lcm(M, N) 或其他值，此处简化：
% 直接使用逆映射公式
unscrambled = inverse_arnold_cat_map(temp, M, N, arnold_iter);
ch_out = unscrambled;
end
function img_out = inverse_arnold_cat_map(img, M, N, iter)
% Arnold猫映射逆变换
% 逆矩阵：[[2,-1],[-1,1]] 模 N
if M ~= N
max_dim = max(M,N);
padded = zeros(max_dim,max_dim);
padded(1:M,1:N) = img;
M = max_dim; N = max_dim;
else
padded = img;
end
img_out = padded;
for k = 1:iter
temp = zeros(M,N);
for i = 1:M
for j = 1:N
% 逆变换：i' = 2i - j, j' = -i + j (mod N)
new_i = mod(2*i - j - 1, M) + 1;
new_j = mod(-i + j - 1, N) + 1;
temp(new_i, new_j) = img_out(i,j);
end
end
img_out = temp;
end
img_out = img_out(1:size(img,1), 1:size(img,2));
end四、使用示例
matlab
%% 多混沌图像加密演示
clear; clc; close all;
% 读取图像
plain = imread('cameraman.tif');
figure; imshow(plain); title('原始图像');
% 设置密钥
keys.logistic_mu = 3.999; % Logistic参数
keys.logistic_x0 = 0.456789; % Logistic初值
keys.chen_init = [0.352, -0.642, 0.838, 0.912]; % Chen初值
keys.arnold_iter = 5; % Arnold迭代次数
% 加密
cipher = chaotic_image_encrypt(plain, keys);
figure; imshow(cipher); title('加密图像');
% 解密
decrypted = chaotic_image_decrypt(cipher, keys);
figure; imshow(decrypted); title('解密图像');
% 安全性分析
% 1. 直方图对比
figure;
subplot(1,2,1); imhist(plain); title('明文直方图');
subplot(1,2,2); imhist(cipher); title('密文直方图');
% 2. 相邻像素相关性（水平方向）
rand_idx = randi([2, numel(plain)-1], 1000, 1);
[~,~,corr_plain] = correlation_analysis(plain, rand_idx);
[~,~,corr_cipher] = correlation_analysis(cipher, rand_idx);
fprintf('明文水平相关系数: %.4f\n', corr_plain);
fprintf('密文水平相关系数: %.4f\n', corr_cipher);五、安全性分析辅助函数
matlab
function [x, y, r] = correlation_analysis(img, indices)
% 计算相邻像素相关系数（水平方向）
img = double(img);
[M,N] = size(img);
x = img(indices);
y = img(indices+1); % 水平相邻
r = corrcoef(x, y);
r = r(1,2);
end参考代码 基于多混沌映射的图像加密 www.youwenfan.com/contentcsv/80981.html
六、性能与安全性指标
| 指标 | 典型值 | 说明 |
|---|---|---|
| 密钥空间 | > (10^{56}) | Logistic初值+参数 + Chen四维初值 |
| 像素相关系数 | < 0.01 | 密文相邻像素几乎不相关 |
| 信息熵 | ≈ 7.997 | 8位灰度图理论最大值8 |
| NPCR | > 99.5% | 像素变化率（抵抗差分攻击） |
| UACI | ≈ 33.5% | 统一平均变化强度 |
七、扩展建议
- 密钥敏感性测试：微调密钥（如 (10^{-15})），观察解密结果差异。
- 抗裁剪攻击：测试部分密文缺失时的恢复能力。
- 多轮加密：可将加密过程重复多次提高安全性。
- 并行加速 ：对彩色图像三通道可使用
parfor并行处理。