博客

学过网络安全的可能知道加密可分为对称加密与非对称加密，比如大名鼎鼎的ssh。非对称加密有RSA,sm9等，对称加密有DES,sm4算法等，但是计算机基础比较扎实的可能知道一个值a与值b异或操作2次后可以恢复原值，这一点是很容易证明的，异或操作可以实现非常简单高效安全的对称加密，值b就是对称密钥。

美国数学家香农证明只要满足以下两个条件，XOR 加密就无法破解

• 
key(对称密钥)

  的长度大于等于
  
message(原文)

• 
key

  必须是一次性的，且每次都要随机产生

原理就是如果每次的

key

都是随机的，那么产生的密文具有所有可能的值，而且是均匀分布，无法从密文看原文的任何特征。

异或加密性能非常优异，加密性能百倍于主流对称加密算法AES。

java实现如下：

/**
     * @description:异或操作对称加解密
     * @param text 原文或者密文
     * @param xorKey 异或运算密钥
     * @exception RuntimeException
     * @return java.lang.String
     */
    public static String getXorString(String text, String xorKey){
        char[] textChars = text.toCharArray(), keyChars = xorKey.toCharArray();
        char[] cipherChars = new char[ textChars.length ];
        for (int i = 0; i < keyChars.length; i++) {
            if (textChars.length <= i) break;

            cipherChars[i] = (char) (textChars[i] ^ keyChars[i]);
        }
        //文本超出xor密钥长度的部分再次去xor加密
        if (textChars.length > keyChars.length){
            char[] remainTextChars = new char[textChars.length - keyChars.length];
            System.arraycopy(textChars, keyChars.length, remainTextChars, 0, textChars.length - keyChars.length);

            char[] remainCipherChars = getXorString(new String(remainTextChars), xorKey).toCharArray();
            System.arraycopy(remainCipherChars, 0, cipherChars, keyChars.length, remainCipherChars.length);
            return new String(cipherChars);
        }
        return new String(cipherChars);
    }

与主流对称加密算法AES性能对比：

1. 异或加密

2.AES加密

3.AES加解密代码

/**
     * @description:cbc模式加密
     * @date 9:39 2022/3/24
     * @param key 密钥
     * @param input 原文
     * @return java.lang.String
     */
    public static String encryptCbc(String key, String input){
        byte[] result = encryptCbc(key.getBytes(), input.getBytes());
        return Base64.getEncoder().encodeToString(result);
    }
    /**
     * @description:cbc模式加密
     * @date 9:39 2022/3/24
     * @param key 密钥
     * @param input 原文
     * @return byte[]
     */
    public static byte[] encryptCbc(byte[] key, byte[] input)  {
        try {
            Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
            SecretKeySpec keySpec = new SecretKeySpec(key, "AES");
            // CBC模式需要生成一个16 bytes的initialization vector:
            SecureRandom sr = SecureRandom.getInstanceStrong();
            byte[] iv = sr.generateSeed(16);
            IvParameterSpec ivps = new IvParameterSpec(iv);
            cipher.init(Cipher.ENCRYPT_MODE, keySpec, ivps);
            byte[] data = cipher.doFinal(input);
            // IV不需要保密，把IV和密文一起返回:
            return join(iv, data);
        } catch (GeneralSecurityException ex){
            throw  new RuntimeException(ex);
        }
    }

    private static byte[] join(byte[] bs1, byte[] bs2) {
        byte[] r = new byte[bs1.length + bs2.length];
        System.arraycopy(bs1, 0, r, 0, bs1.length);
        System.arraycopy(bs2, 0, r, bs1.length, bs2.length);
        return r;
    }
    /**
     * @description:cbc模式解密
     * @date 9:39 2022/3/24
     * @param key 密钥
     * @param input 密文
     * @return java.lang.String
     */
    public static String decryptCbc(String key, String input){
        byte[] result = decryptCbc(key.getBytes(), Base64.getDecoder().decode(input));
        return new String(result);
    }
    /**
     * @description:cbc模式解密
     * @date 9:39 2022/3/24
     * @param key 密钥
     * @param input 密文
     * @return byte[]
     */
    public static byte[] decryptCbc(byte[] key, byte[] input)  {
        // 把input分割成IV和密文:
        byte[] iv = new byte[16];
        byte[] data = new byte[input.length - 16];
        System.arraycopy(input, 0, iv, 0, 16);
        System.arraycopy(input, 16, data, 0, data.length);
        // 解密:
        try {
            Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
            SecretKeySpec keySpec = new SecretKeySpec(key, "AES");
            IvParameterSpec ivps = new IvParameterSpec(iv);
            cipher.init(Cipher.DECRYPT_MODE, keySpec, ivps);
            return cipher.doFinal(data);
        } catch (GeneralSecurityException ex){
            throw new RuntimeException(ex);
        }
    }