对称加密算法学习记录——Java

文章目录

  • 一、引言
  • 二、对称加密基础
  • 三、对称加密算法
    • 3.1 DES
    • 3.2 3DES
    • 3.3 AES
    • 3.4 PBE
  • 四、代码实现(java)
    • 4.1 PBE算法实现(常用)
    • 4.2 DES算法实现
    • 4.3 3DES算法实现
    • 4.4 AES算法实现
  • 五、其它


一、引言

计算机中的一种位运算,与或非。下面这种运算叫做异或运算,是与或非运算的变形:
0 XOR 0 = 0
0 XOR 1 = 1
1 XOR 0 = 1
1 XOR 1 = 0
从上面的结果我们可以看到,两个数相同就返回为0,不相同就是为1;
从这个运算规则中我们还可以得到很多规律,其中有一条很重要的交换律,就是我们对称加密算法的核心。
 a ⊕ b ⊕ c = a ⊕ (b ⊕ c) = (a ⊕ b) ⊕ c  
 变形:
 a ⊕ b ⊕ b = a ⊕ (b ⊕ b) = a ⊕ 0 = a
 /*
    假设
        a是原文(要加密的数据)
        b是秘钥
    结果:
        第一次使用b加密 a==> a ⊕ b 
        第二次使用b解密 a ⊕ b ⊕ b ==>a
 */
从上面我们可以看到了,通过b加密,然后再通过b解密就可以拿到源数据a了。这就是对称加密的思想核心。

不过到这我们可以会发现一个问题,秘钥b是非常核心重要的一个数据,如果我们的b泄露了,那么我们的数据a也就被泄漏了。

OK。到了这我们的算是稍微明白一点对称加密的意思了。下面我们就开始正式的认识一下对称加密。

二、对称加密基础

为了对上面的过程理解方便,我们使用一个案例来进行展示,比如说我们要对数据homework进行加密解密。

对称加密算法学习记录——Java_第1张图片

对照这两个相反的过程,数据是一一对应的。这种方式其实叫做:'一次性加密本',现在你应该明白对称加密是个啥玩意了吧。
这种加密算法看起来很简单,那么在实际当中一定广泛使用吧,真实情况确实没有人用,我们来分析一下这种方式的缺点:

(1)秘钥传输过程中很容易被截获
(2)原文很长时,秘钥也很长
(3)保存秘钥很困难
(4)秘钥的正确定无法保证:也就是说秘钥错一位,基本上整个秘钥报废了。
鉴于有这些缺点,因此出现很多其他对称加密的算法。

三、对称加密算法

基于对称加密机制的算法有很多,比如说DES、3DES、AES、PBE。我们一个一个先来认识一下,
不会涉及到底层太多,对每一种算法的实现,我会花费专门的文章进行讲解分析。

3.1 DES

DES 是一种把 64 位明文加密成 64 位密文的对称加密算法。它的密钥长度为 64 比特,
但是每 7 个二进制位会设置一个用于错误检测的位,实际上密钥长度就剩下了 56 比特。
DES 只能一次性加密 64 位明文,如果明文超过了 64 位,就要进行分组加密。

对称加密算法学习记录——Java_第2张图片

上面的过程是加密,解密过程反过来就能明白,这种方式有很大的缺点,不管是加密还是解密,
都有很大的不安全性。一般不会使用。

3.2 3DES

这种方式就是为了避免DES的缺点,既然DES加密一次会不安全,那就多加几个步骤,
这里加密解密再加密三次就叫做三重DES。DES 密钥长度为 56 位,所以 3DES 密钥长度为 56 * 3 = 168 位。

对称加密算法学习记录——Java_第3张图片
注意:这里可不是对DES执行了三次加密解密的操作,而是加密-解密-加密。

上面的流程同样是只给出了加密的过程,当然对于解密的过程也很简单,反过来解密-加密-解密。
3DES 是对DES的一个升级,但是由于速度不高,因此也在淘汰。

3.3 AES

AES算是一种比较常见的加密算法了,AES为分组密码,也就是把明文分成一组一组的、长度相等、每组16个字节的数据,
每次加密一组数据,直到加密完整个明文。
在AES标准规范中,分组长度只能是128位。但是密钥的长度可以使用128位、192位或256位。

这里你可能有个疑问,在文章一开始不是说了嘛。对称加密机制我们的数据明文128位,那么秘钥要一一对应,
应该也是128位呀?其实AES实施的多次加密,密钥的长度不同,推荐加密轮数也不同。

对称加密算法学习记录——Java_第4张图片
内部细节没有给出。

3.4 PBE

PBE是一种基于口令的加密算法,其特点在于口令是由用户自己掌握的,采用随机数杂凑多重加密等方法保证数据的安全性。
没有密钥的概念,密钥在其它对称加密算法中是经过算法计算得出来的,PBE算法则是使用口令替代了密钥。

对称加密算法学习记录——Java_第5张图片
这就是加密的整个流程。很简单的一个流程。

四、代码实现(java)

在正式的代码编写之前,我们先要认识一下工具类,它是把byte转换为16进制String。
也就是说把加密之后的数据转变成16进制String。
public static String byteArrayToHexStr(byte[] byteArray) {
    if (byteArray == null){
        return null;
    }
    char[] hexArray = "0123456789ABCDEF".toCharArray();
    char[] hexChars = new char[byteArray.length * 2];
    for (int j = 0; j < byteArray.length; j++) {
        int v = byteArray[j] & 0xFF;
        hexChars[j * 2] = hexArray[v >>> 4];
        hexChars[j * 2 + 1] = hexArray[v & 0x0F];
    }
    return new String(hexChars);
}

4.1 PBE算法实现(常用)

 public static void PBE(){
        try {
            //第一步: 初始化盐
            SecureRandom random = new SecureRandom();
            byte[] salt = random.generateSeed(8);
            //第二步: 口令与密钥
            String password = "timliu";
            PBEKeySpec pbeKeySpec = new PBEKeySpec(password.toCharArray()); 
            SecretKeyFactory factory = SecretKeyFactory.getInstance("PBEWITHMD5andDES");
            Key key = factory.generateSecret(pbeKeySpec);                       
            //第三步: 加密
            PBEParameterSpec pbeParameterSpac = new PBEParameterSpec(salt, 100);
            Cipher cipher = Cipher.getInstance("PBEWITHMD5andDES");
            cipher.init(Cipher.ENCRYPT_MODE, key, pbeParameterSpac);
            byte[] result = cipher.doFinal(src.getBytes());
            System.out.println("加密之后的秘文:" + byteArrayToHexStr(result));     
            //第四步: 解密
            cipher.init(Cipher.DECRYPT_MODE, key, pbeParameterSpac);
            result = cipher.doFinal(result);
            System.out.println("解密之后的明文:" + new String(result));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

4.2 DES算法实现

public static void DES(){
        try {
            //第一步: 生成KEY
            KeyGenerator keyGenerator = KeyGenerator.getInstance("DES");            
            keyGenerator.init(56);//56位
            //第二步: 产生密钥
            SecretKey secretKey = keyGenerator.generateKey();
            //第三步: 获取密钥
            byte[] bytesKey = secretKey.getEncoded();   
            //第四步: KEY转换
            DESKeySpec desKeySpec = new DESKeySpec(bytesKey);
            SecretKeyFactory factory = SecretKeyFactory.getInstance("DES");
            Key convertSecretKey = factory.generateSecret(desKeySpec);  
            //第五步: 加密
            Cipher cipher = Cipher.getInstance("DES/ECB/PKCS5Padding");
            cipher.init(Cipher.ENCRYPT_MODE, convertSecretKey);
            byte[] result = cipher.doFinal(src.getBytes());
            System.out.println("加密之后的秘文:" + byteArrayToHexStr(result));     
            //第六步: 解密
            cipher.init(Cipher.DECRYPT_MODE, convertSecretKey);
            result = cipher.doFinal(result);
            System.out.println("解密之后的明文:" + new String(result));        
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

4.3 3DES算法实现

 public static void 3DES(){
        try {
            //第一步: 生成KEY
            KeyGenerator keyGenerator = KeyGenerator.getInstance("DESede"); 
            //第二步: 必须长度是:112或168
            keyGenerator.init(168);
            //第三步: 产生密钥
            SecretKey secretKey = keyGenerator.generateKey();
            //第四步: 获取密钥
            byte[] bytesKey = secretKey.getEncoded();
            //第五步: KEY转换
            DESedeKeySpec desKeySpec = new DESedeKeySpec(bytesKey);
            SecretKeyFactory factory = SecretKeyFactory.getInstance("DESede");
            Key convertSecretKey = factory.generateSecret(desKeySpec);
            //第六步: 加密
            Cipher cipher = Cipher.getInstance("DESede/ECB/PKCS5Padding");
            cipher.init(Cipher.ENCRYPT_MODE, convertSecretKey);
            byte[] result = cipher.doFinal(src.getBytes());
            System.out.println("加密之后的秘文:" + byteArrayToHexStr(result)); 
            //第七步: 解密
            cipher.init(Cipher.DECRYPT_MODE, convertSecretKey);
            result = cipher.doFinal(result);
            System.out.println("解密之后的明文:" + new String(result));    
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

4.4 AES算法实现

public static void AES(){
        try {
            //第一步: 生成KEY
            KeyGenerator keyGenerator = KeyGenerator.getInstance("AES");            
            keyGenerator.init(128);
            //第二步: 产生密钥
            SecretKey secretKey = keyGenerator.generateKey();
            //第三步: 获取密钥
            byte[] keyBytes = secretKey.getEncoded();
            //第四步: KEY转换
            Key key = new SecretKeySpec(keyBytes, "AES");
            //第五步: 加密
            Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
            cipher.init(Cipher.ENCRYPT_MODE, key);
            byte[] result = cipher.doFinal(src.getBytes());
            System.out.println("加密之后的秘文:" + byteArrayToHexStr(result)); 
            //第六步: 解密
            cipher.init(Cipher.DECRYPT_MODE, key);
            result = cipher.doFinal(result);
            System.out.println("解密之后的明文:" + new String(result));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

五、其它

补充-Java 8后Base64编码和解码
final Base64.Decoder decoder = Base64.getDecoder();
final Base64.Encoder encoder = Base64.getEncoder();
final String text = "字串文字";
final byte[] textByte = text.getBytes("UTF-8");
//編碼
final String encodedText = encoder.encodeToString(textByte);
System.out.println(encodedText);
//解碼
System.out.println(new String(decoder.decode(encodedText), "UTF-8"));
與sun.misc套件和Apache Commons Codec所提供的Base64編解碼器來比較的話,
Java 8提供的Base64擁有更好的效能。實際測試編碼與解碼速度的話,Java 8提供的Base64,
要比sun.misc套件提供的還要快至少11倍,比Apache Commons Codec提供的還要快至少3倍。
因此在Java上若要使用Base64,這個Java 8底下的java.util套件所提供的Base64類別絕對是首選!

参考文章:https://magiclen.org/java-base64/
知乎文章:https://zhuanlan.zhihu.com/p/81650731

你可能感兴趣的:(算法,算法,加密解密)