伪量子加密算法

缺乏、安全感 2022-02-23 08:14 288阅读 0赞

### 文章目录 ###

*  量子加密
 *   *  什么是量子加密
     *  量子加密的特点
     *  量子加密的使用方法
 *  伪量子加密
 *  源码
 *  结果

# 量子加密 #

## 什么是量子加密 ##

任何一串信息都可以表示成一串二进制字符，也就是由0或1组成的字符串。对于由01组成的字符串的每位数字a，我们都可以给它一个对应的密钥k，这个k也是一个0或1的数字，根据a和k就可以算出对应的密文b，它也是一个0或1的数字。这对应的规则就是，如果k = 0，那么b就等于a，如果k = 1，那么b就等于0和1当中不等于a的那一个。

也就是说，如果k等于0，那么就把0变成0,1变成1；而k等于1，则把0变成1，1变成0。

再简单来说就是k等于0不变，则k等于1就0,1互换。其也被称为“异或”或者“模为2的加法”等。

量子加密虽然其原理简单，但是它却可实现高保密性，其诀窍不在于算法，而在于密钥。

实际上，对于原文的每一位，都相应的有一位密钥，也就是说如果原文的长度是n位，则密钥的长度也是n位。

这还没有完，这串字符串还必须是个随机的字符串，也就是说每一位都是随机的0或者1任何的两位数之间没有任何联系。而这仍然没完，而这么长的密钥还只能用一次。也就是说，你这次用n位的秘钥传输了n位的原文，下次你传同样的内容，还必须从头再来，重新构造n位的密钥。千万不能把原来的密钥再用一次，这就叫做一次一密。

## 量子加密的特点 ##

总结而言，量子密码中的密钥是满足这么三种条件的字符串：

*  **长度跟明文相等**
 *  **随机**
 *  **一次一密**

之所以这么做，是因为其绝对不会被任何数学方法破译。因为这样一段密文，可能对应一段跟它等长的任何一段明文，而且概率相等。

在密码学当中一个重要的定理就是：**用一次性便笺加密的密文是绝对不可破译的**。而这条信息的定理是**克劳德·香农**证明的。

## 量子加密的使用方法 ##

量子加密的具体使用就是：将明文用量子秘钥进行加密，生成密文，然后密文通过普通途径传输，而与此同时，秘钥通过量子信道传输。由于发送方与接收方是通过量子纠缠现象保证双方秘钥的一致性，而该秘钥由于在产生过程中没有经过信使，因而其本身就保证了秘钥无法被截获，因而量子通信是通过物理手段保证是绝对安全的。

# 伪量子加密 #

通过上面的说明，我们就不难理解什么是量子加密，由于量子加密是通过同时在不同线路上传输密文与秘钥，进而实现的超强加密功能。

量子加密的流程如下：

发送方：明文->二进制->加密->传输
    接收方：传入->解密->二进制->明文

而伪量子加密算法（姑且我这么定义），与其类似，也是分别通过密文与秘钥来实现的加密，只是与真正的量子加密不同之处在于，我这里的秘钥指的是当前系统的时间戳，**由于时间的单向流动性，因而通过时间戳来保证生成的密文永远唯一，不会重复**。

当然，说完了这一特点，我们就不难理解，伪量子加密算法要想破解，必须得满足三个条件，那就是：

*  **知晓加密规则**
 *  **通信的双方，必须同时在线**
 *  **其两端的电子设备，其时间是一致的，差一秒都不行**

而我这里的伪量子加密算法流程与其类似

发送方：明文->二进制->扰码->传输
    接收方：传入->扰码->二进制->明文

而这种加密算法也符合量子加密算法的如下特点，只是此处的随机是依赖的通信时间的随机且不重复的特点（时间的单向流动性）。

*  **长度跟明文相等**
 *  **随机**
 *  **一次一密**

# 源码 #

Binary

package com.lyc.pseudoQuantumCryptography.core;
    
    /** * @author: zhangzhenyi * @date: 2019/4/7 8:43 * @description: 字符串与二进制互转 **/
    public class Binary { 
    
        /** * 将字符串转换成二进制 * @param str 输入字符串 * @return */
        public String toBinary(String str){ 
            // 将字符串转换成char数组
            char[] strCharArray = str.toCharArray();
            StringBuilder result = new StringBuilder();
            for (char aStrCharArray : strCharArray) { 
                // 获取系统的当前时间
                String currentTime = MappingTable.newMappingTable().getCurrentTime();
                // 以字符乘以当前时间戳进行加密操作
                Long currentStr = aStrCharArray * Long.valueOf(currentTime);
                // 将加密后的信息转换成字节码
                result.append(Long.toBinaryString(currentStr));
                result.append(" ");
            }
            int lastIndexOfSpace = result.lastIndexOf(" ");
            // 取消结尾处的空格
            result.delete(lastIndexOfSpace,lastIndexOfSpace + 1);
            return result.toString();
        }
    
        /** * 将二进制转换成字符串 * @param str * @return */
        public String toString(String str){ 
            // 将二进制转换成字符串数组
            String[] binCharArray = str.split(" ");
            char[] resultCharArray = new char[binCharArray.length];
            for(int i = 0, binCharArrayLength = binCharArray.length; i < binCharArrayLength; i ++){ 
                // 将二进制转换成int数组
                long[] intArray = binaryToIntArray(binCharArray[i]);
                char charResult = intArrayToChar(intArray);
                resultCharArray[i] = charResult;
            }
            return String.valueOf(resultCharArray);
        }
    
        /** * 将二进制转换成int数组 * @param bin * @return */
        private long[] binaryToIntArray(String bin){ 
            // 将二进制转换成char
            char[] temp = bin.toCharArray();
            long[] result = new long[temp.length];
            for(int i = 0; i< temp.length; i ++) { 
                result[i] = temp[i] - 48;
            }
            return result;
        }
    
        /** * 将int数组转换成Char * @param intArray * @return */
        private char intArrayToChar(long[] intArray){ 
            Long sum = 0L;
            for(int i = 0, intArrayLength = intArray.length; i < intArrayLength; i ++){ 
                sum += intArray[intArray.length - 1 - i] << i;
            }
            // 获取系统的当前时间
            String currentTime = MappingTable.newMappingTable().getCurrentTime();
            // 用Long数据除以当前时间戳
            sum = sum / Long.valueOf(currentTime);
            // 将Long类型的数据转换成int类型
            int charEle = Integer.valueOf(String.valueOf(sum));
            // 将int类型的数据强转成char
            return (char) charEle;
        }
    
        /** * 创建Binary对象 * @return */
        public static Binary newBinary(){ 
            return new Binary();
        }
    
    }

MappingTable

package com.lyc.pseudoQuantumCryptography.core;
    
    import org.joda.time.DateTime;
    
    /** * @author: zhangzhenyi * @date: 2019/4/7 10:08 * @description: 扰码（只有在同一时间内才有效） **/
    public class MappingTable { 
    
        /** * 创建MappingTable对象 * @return */
        public static MappingTable newMappingTable(){ 
            return new MappingTable();
        }
    
        /** * 获取系统的当前时间 * @return */
        public String getCurrentTime(){ 
            DateTime dateTime = new DateTime();
            // 格式化成以秒为时间单位，防止因时间太短，出现信息编译偏差
            return dateTime.toString("yyyyMMddHHmmss");
        }
    
        /** * 获取系统当前的秒 * @return */
        private String getCurrentSecond(){ 
            String currentTimeString = getCurrentTime();
            // 截取最后一个字符(秒)
            return currentTimeString.substring(currentTimeString.length() - 1,currentTimeString.length());
        }
    
        /** * 编码 * @param c 二进制字符 * @param second 秒 * @return */
        private String encode(char c, String second) { 
            // 将截取的最后一个字符穿转成int
            int secondInt = Integer.valueOf(second);
            // 对2求余，奇数取反，偶数不变
            int flag = secondInt % 2;
            if(0 == flag){ 
                return String.valueOf(c);
            } else { 
                return 0 == Integer.valueOf(String.valueOf(c)) ? "1" : "0" ;
            }
        }
    
        /** * 完成二进制的扰码操作 * @param str * @return */
        public String scramble(String str){ 
            // 将字符串转换成字节码
            char[] charArray = str.toCharArray();
            // 扰码后的结果
            StringBuffer result = new StringBuffer();
            for(char charEle : charArray){ 
                String charEleString = String.valueOf(charEle);
                // 如果当前项含有空格，则无需执行扰码操作，否则执行
                if(!charEleString.equals(" ")){ 
                    // 获取系统当前的秒
                    String second = getCurrentSecond();
                    // 完成当前的二进制字符的扰码操作
                    result.append(encode(charEle,second));
                } else { 
                    result.append(charEle);
                }
            }
            // 返回扰码后的结果
            return result.toString();
        }
    
    }

PseudoQuantumCryptographyTest单元测试类

package com.lyc.pseudoQuantumCryptography;
    
    import com.lyc.pseudoQuantumCryptography.core.Binary;
    import com.lyc.pseudoQuantumCryptography.core.MappingTable;
    import lombok.extern.slf4j.Slf4j;
    import org.junit.Test;
    
    /** * @author: zhangzhenyi * @date: 2019/4/7 11:39 * @description: 伪量子加密算法单元测试 **/
    @Slf4j
    public class PseudoQuantumCryptographyTest { 
    
        @Test
        public void test(){ 
            String hello = "你好！";
            log.info("扰码前：{}",hello);
            // 转换成二进制
            String bin = Binary.newBinary().toBinary(hello);
            log.info("扰码前的二进制：{}",bin);
            // 扰码
            String enBin = MappingTable.newMappingTable().scramble(bin);
            log.info("扰码后的二进制：{}",enBin);
            // 解码
            String deBin = MappingTable.newMappingTable().scramble(enBin);
            log.info("解码后的二进制：{}",deBin);
            // 将二进制转换成字符串
            String decryptStr = Binary.newBinary().toString(deBin);
            // 打印最终结果
            log.info("最终结果：{}",decryptStr);
        }
    
    }

# 结果 #

第一次运行：

15:55:43.147 [main] INFO com.lyc.pseudoQuantumCryptography.PseudoQuantumCryptographyTest - 扰码前：你好！
    15:55:43.258 [main] INFO com.lyc.pseudoQuantumCryptography.PseudoQuantumCryptographyTest - 扰码前的二进制：10110110001100100011000110001101110010111111001100110100000 11001101011010001111000100001010000011100010100110001111011 1001001001010101001110111011011000101100000111000100001010111
    15:55:43.266 [main] INFO com.lyc.pseudoQuantumCryptography.PseudoQuantumCryptographyTest - 扰码后的二进制：01001001110011011100111001110010001101000000110011001011111 00110010100101110000111011110101111100011101011001110000100 0110110110101010110001000100100111010011111000111011110101000
    15:55:43.268 [main] INFO com.lyc.pseudoQuantumCryptography.PseudoQuantumCryptographyTest - 解码后的二进制：10110110001100100011000110001101110010111111001100110100000 11001101011010001111000100001010000011100010100110001111011 1001001001010101001110111011011000101100000111000100001010111
    15:55:43.269 [main] INFO com.lyc.pseudoQuantumCryptography.PseudoQuantumCryptographyTest - 最终结果：你好！

第二次运行：

16:07:21.411 [main] INFO com.lyc.pseudoQuantumCryptography.PseudoQuantumCryptographyTest - 扰码前：你好！
    16:07:21.554 [main] INFO com.lyc.pseudoQuantumCryptography.PseudoQuantumCryptographyTest - 扰码前的二进制：10110110001100100011000110001110100101001010001010101100000 11001101011010001111000100001010111100000110101011011001101 1001001001010101001110111011011011001101010010110001010010001
    16:07:21.564 [main] INFO com.lyc.pseudoQuantumCryptography.PseudoQuantumCryptographyTest - 扰码后的二进制：01001001110011011100111001110001011010110101110101010011111 00110010100101110000111011110101000011111001010100100110010 0110110110101010110001000100100100110010101101001110101101110
    16:07:21.568 [main] INFO com.lyc.pseudoQuantumCryptography.PseudoQuantumCryptographyTest - 解码后的二进制：10110110001100100011000110001110100101001010001010101100000 11001101011010001111000100001010111100000110101011011001101 1001001001010101001110111011011011001101010010110001010010001
    16:07:21.569 [main] INFO com.lyc.pseudoQuantumCryptography.PseudoQuantumCryptographyTest - 最终结果：你好！

通过上面的两次运行结果，我们可以看到，之前的字符串“你好！”最终又被成功的解密了，但是由于时间戳的不一致，导致中间过程中生成的密文却是不一样的，通过这种方式，我们就保证了伪量子加密的可靠性。