# Logistic混沌序列加密

**Repository Path**: coyamo/logistic_image

## Basic Information

- **Project Name**: Logistic混沌序列加密
- **Description**: Logistic混沌序列加密
- **Primary Language**: Java
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 2
- **Forks**: 0
- **Created**: 2021-04-16
- **Last Updated**: 2024-12-24

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README


# Logistic混沌序列

首先选取一种典型的Logistic混沌序列，如下：
$$
x_{n+1}= \lambda x_{n}\left ( 1-x_{n} \right ),x_{n}\in [0,1]
$$
其中 $3.569946… \leq \lambda \leq 4 ， 0 < x_{n} < 1$

# 效果图
![加密效果图](https://img-blog.csdnimg.cn/20210416214929136.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3MzQ4MzY0,size_16,color_FFFFFF,t_70#pic_center)


# 关键代码

`input`是输入的图像文件，建议是`bmp`格式。因为我用`jpg`和`png`等格式输入，处理后的图片解密出来图片有乱码。这里不深究。
`password`是八位的密码，最终转换为两个$\lambda$
`encode`参数控制是加密还是解密，解密是加密的逆过程。
`name`是处理后的图片的名字
```java
public static File process(File input,int password,boolean encode, String name) {
        float x0_1,x0_2;
        //这里固定为4
        float u=4f;
        
        password%=100000000;
        x0_1=(password%10000)*0.0001f;//1~4
        x0_2=(password/10000)*0.0001f;//5~8
        
        try {
            BufferedImage image = ImageIO.read(input);
            int width = image.getWidth(),
                    height = image.getHeight();
            int size = width * height;
            int[] rgb = new int[size];
            //读取像素从上到下，从左至右
            image.getRGB(0, 0, width, height, rgb, 0, width);
            
            float[] x = new float[size];
            //生成用于位置置换的混沌序列
            x[0] = x0_1;
            //迭代500次达到有效的混沌
            for (int i = 0; i < 500; i++)
                x[0] = u * x[0] * (1 - x[0]);
            for (int i = 0; i < size - 1; i++)
                x[i + 1] = u * x[i] * (1 - x[i]);
                
            //根据混沌序列生成置换表
            int[] index=sort(x);
            //位置置换
            int[] rgb_rep=new int[size];
            if(encode){
                for (int i = 0; i <size; i++)
                    rgb_rep[i]=rgb[index[i]];
            }else  System.arraycopy(rgb, 0, rgb_rep, 0, size); 
           
            //像素置换
            x[0] = x0_2;
            for (int i = 0; i < 500; i++)
                x[0] = u * x[0] * (1 - x[0]);
            for (int i = 0; i < size - 1; i++)
                x[i + 1] = u * x[i] * (1 - x[i]);
            for (int i = 0; i < size; i++) {
            	//归一化
            	//0~1的值转换0x00000000~0x00FFFFFF
                x[i] = x[i] * 0xffffff;
                //异或
                rgb_rep[i] = rgb_rep[i] ^ (int) x[i];
            }
            
            //解密位置置换
            if(!encode){
                for (int i = 0; i <size; i++)
                    rgb[index[i]]=rgb_rep[i];
                rgb_rep=rgb;
            }
            
            image.flush();
            image = new BufferedImage(width, height, image.getType());
            image.setRGB(0, 0, width, height, rgb_rep, 0, width);
            String suffix = input.getName().substring(input.getName().lastIndexOf('.') + 1);
            File out=new File(input.getParent(), name + "." + suffix);
            ImageIO.write(image, suffix,out );
            image.flush();
            return out;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

```
根据混沌矩阵，非降序排序生成置换矩阵。理论上置换矩阵可以按其他的算法生成。这里是非降序排序。
```java
	private static int[] sort(float[] x){
        int size=x.length;
        int[] index=new int[size];//置换表
        for (int i = 0; i <size; i++){
            index[i]=i;
        }
        for (int i = 0; i <size-1; i++) {
            int min = i;
            for (int j = i + 1; j < size; j++) {
                if (x[min] > x[j]) {
                    min = j;
                }
            }
            float temp = x[min];
            x[min] = x[i];
            x[i] = temp;

            int temp2 = index[min];
            index[min] = index[i];
            index[i] = temp2;
        }
        return index;
    }
```


# 参考
[【1】加密例图 Lena](https://baike.baidu.com/item/%E8%8E%B1%E5%A8%9C%C2%B7%E7%91%9F%E5%BE%B7%E8%B4%9D%E9%87%8C/10916076?fr=aladdin)
[【2】像素值双重置换与像素位置的混沌加密算法](https://www.jiamisoft.com/blog/6047-xiangsuzhihunduanjiamisuanfa.html)