快速了解常用的对称加密算法，再也不用担心面试官的刨根问底

╰+哭是因爲堅強的太久メ 2023-10-01 16:13 7阅读 0赞

> 面试官：说一说你常用的加密算法有哪些？

加密算法通常被分为两种：**对称加密**和**非对称加密**。其中，对称加密算法在加密和解密时使用的密钥相同；非对称加密算法在加密和解密时使用的密钥不同，分为公钥和私钥。此外，还有一类叫做**消息摘要算法**，是对数据进行摘要并且不可逆的算法。

这次我们了解一下对称加密算法。

#### 对称加密算法 ####

对称加密算法在加密和解密时使用的密钥相同，或是使用两个可以简单地相互推算的密钥。在大多数的对称加密算法中，加密和解密的密钥是相同的。

它要求双方在安全通信之前，商定一个密钥。对称算法的安全性依赖于密钥，泄漏密钥就意味着任何人都可以对他们发送的信息进行解密，这也是对称加密算法的主要缺点之一。

常见的对称加密算法有：DES算法、3DES算法、AES算法。

#### DES算法 ####

DES算法（Data Encryption Standard）是一种常见的分组加密算法。

> 面试官：什么是分组加密算法？

分组加密算法是将明文分成固定长度的组，每一组都采用同一密钥和算法进行加密，输出也是固定长度的密文。

由IBM公司在1972年研制，1976年被美国联邦政府的国家标准局确定为联邦资料处理标准（FIPS），随后在国际上广泛流传开来。

在DES算法中，密钥固定长度为64位。明文按64位进行分组，分组后的明文组和密钥按位置换或交换的方法形成密文组，然后再把密文组拼装成密文。

密钥的每个第八位设置为奇偶校验位，也就是第8、16、24、32、40、48、56、64位，所以密钥的实际参与加密的长度为56位。

我们用Java写个例子：

import javax.crypto.Cipher;
    import javax.crypto.SecretKey;
    import javax.crypto.spec.SecretKeySpec;
    import java.nio.charset.Charset;
    import java.nio.charset.StandardCharsets;
    import java.security.GeneralSecurityException;
    import java.util.Base64;
    
    public class DesUtil {
        
    
        private static final String DES = "DES";
        private static final Charset CHARSET = StandardCharsets.UTF_8;
    
        /**
         * 加密
         *
         * @param input 明文
         * @param key   密钥
         * @return 密文
         * @throws GeneralSecurityException
         */
        public static String encrypt(String input, String key) throws GeneralSecurityException {
        
            Cipher cipher = Cipher.getInstance(DES);
            SecretKey keySpec = new SecretKeySpec(key.getBytes(CHARSET), DES);
            cipher.init(Cipher.ENCRYPT_MODE, keySpec);
            byte[] data = cipher.doFinal(input.getBytes(CHARSET));
            return Base64.getEncoder().encodeToString(data);
        }
    
        /**
         * 解密
         *
         * @param input 密文
         * @param key   密钥
         * @return 明文
         * @throws GeneralSecurityException
         */
        public static String decrypt(String input, String key) throws GeneralSecurityException {
        
            Cipher cipher = Cipher.getInstance(DES);
            SecretKey keySpec = new SecretKeySpec(key.getBytes(CHARSET), DES);
            cipher.init(Cipher.DECRYPT_MODE, keySpec);
            byte[] data = cipher.doFinal(Base64.getDecoder().decode(input));
            return new String(data, CHARSET);
        }
    
        public static void main(String[] args) throws GeneralSecurityException {
        
            String msg = "我喜欢你，可以做我女朋友吗？";
            String key = "One-More";
            System.out.println("加密前：" + msg);
            String pwd = DesUtil.encrypt(msg, key);
            System.out.println("加密后：" + pwd);
            System.out.println("解密后：" + DesUtil.decrypt(pwd, key));
        }
    }

运行结果如下：

加密前：我喜欢你，可以做我女朋友吗？
    加密后：i5LZ5aJMrlgN+Pr5IQm87Q14k0kmDLFIPnJmtrGA/xBHG0SivGrqCrc3vXjZoCBm
    解密后：我喜欢你，可以做我女朋友吗？

**DES现在已经不是一种安全的加密方法，主要因为它使用的密钥过短，很容易被暴力破解。**

#### 3DES算法 ####

3DES算法（Triple Data Encryption Algorithm）是DES算法的升级版本，相当于是对明文进行了三次DES加密。

由于计算机运算能力的增强，DES算法由于密钥长度过低容易被暴力破解；3DES算法提供了一种相对简单的方法，即通过增加DES的密钥长度来避免类似的攻击，而不是设计一种全新的块密码算法。

在DES算法中，密钥固定长度为192位。在加密和解密时，密钥会被分为3个64位的密钥。

> 面试官：3DES算法加密和解密的过程是什么样子的？

加密过程如下：

1.  使用第一个密钥加密明文。
2.  使用第二个密钥解密上一步的结果。
3.  使用第三个密钥加密上一步的结果。

解密过程如下：

1.  使用第三个密钥解密明文。
2.  使用第二个密钥加密上一步的结果。
3.  使用第一个密钥解密上一步的结果。

我们用Java写个例子：

import javax.crypto.Cipher;
    import javax.crypto.SecretKey;
    import javax.crypto.spec.SecretKeySpec;
    import java.nio.charset.Charset;
    import java.nio.charset.StandardCharsets;
    import java.security.GeneralSecurityException;
    import java.util.Base64;
    
    public class TripleDesUtil {
        
    
        private static final String DESede = "DESede";
        private static final Charset CHARSET = StandardCharsets.UTF_8;
    
        /**
         * 加密
         *
         * @param input 明文
         * @param key   密钥
         * @return 密文
         * @throws GeneralSecurityException
         */
        public static String encrypt(String input, String key) throws GeneralSecurityException {
        
            Cipher cipher = Cipher.getInstance(DESede);
            SecretKey keySpec = new SecretKeySpec(key.getBytes(CHARSET), DESede);
            cipher.init(Cipher.ENCRYPT_MODE, keySpec);
            byte[] data = cipher.doFinal(input.getBytes(CHARSET));
            return Base64.getEncoder().encodeToString(data);
        }
    
        /**
         * 解密
         *
         * @param input 密文
         * @param key   密钥
         * @return 明文
         * @throws GeneralSecurityException
         */
        public static String decrypt(String input, String key) throws GeneralSecurityException {
        
            Cipher cipher = Cipher.getInstance(DESede);
            SecretKey keySpec = new SecretKeySpec(key.getBytes(CHARSET), DESede);
            cipher.init(Cipher.DECRYPT_MODE, keySpec);
            byte[] data = cipher.doFinal(Base64.getDecoder().decode(input));
            return new String(data, CHARSET);
        }
    
        public static void main(String[] args) throws GeneralSecurityException {
        
            String msg = "我喜欢你，可以做我女朋友吗？";
            String key = "One-More12345678One.More";
            System.out.println("加密前：" + msg);
            String pwd = TripleDesUtil.encrypt(msg, key);
            System.out.println("加密后：" + pwd);
            System.out.println("解密后：" + TripleDesUtil.decrypt(pwd, key));
        }
    }

运行结果如下：

加密前：我喜欢你，可以做我女朋友吗？
    加密后：q/ZWtjDGoxIjmd30he0oZ3XLjJhh/ACedaXaj12Zi3Wtlqz+ZzJmQuScjKuZoONF
    解密后：我喜欢你，可以做我女朋友吗？

**虽然3DES算法在安全性上有所提升，但是因为使用了3次DES算法，加密和解密速度比较慢。**

#### AES算法 ####

AES（Advanced Encryption Standard，高级加密标准）主要是为了取代DES加密算法的，虽然出现了3DES的加密方法，但由于它的加密时间是DES算法的3倍多，密钥位数还是不能满足对安全性的要求。

1997年1月2号，美国国家标准与技术研究院（NIST）宣布希望征集高级加密标准，用以取代DES。全世界很多密码工作者都提交了自己设计的算法。经过甄选流程，高级加密标准由美国国家标准与技术研究院于2001年11月26日发布于FIPS PUB 197，并在2002年5月26日成为有效的标准。

该算法为比利时密码学家Joan Daemen和Vincent Rijmen所设计，结合两位作者的名字，以**Rijndael**为名投稿高级加密标准的甄选流程。

> 面试官：AES算法的密钥长度是固定的吗？

AES算法的密钥长度是固定，密钥的长度可以使用128位、192位或256位。

AES算法也是一种分组加密算法，其分组长度只能是128位。分组后的明文组和密钥使用几种不同的方法来执行排列和置换运算形成密文组，然后再把密文组拼装成密文。

我们用Java写个例子：

import javax.crypto.Cipher;
    import javax.crypto.SecretKey;
    import javax.crypto.spec.SecretKeySpec;
    import java.nio.charset.Charset;
    import java.nio.charset.StandardCharsets;
    import java.security.GeneralSecurityException;
    import java.util.Base64;
    
    public class AesUtil {
        
    
        private static final String AES = "AES";
        private static final Charset CHARSET = StandardCharsets.UTF_8;
    
        /**
         * 加密
         *
         * @param input 明文
         * @param key   密钥
         * @return 密文
         * @throws GeneralSecurityException
         */
        public static String encrypt(String input, String key) throws GeneralSecurityException {
        
            Cipher cipher = Cipher.getInstance(AES);
            SecretKey keySpec = new SecretKeySpec(key.getBytes(CHARSET), AES);
            cipher.init(Cipher.ENCRYPT_MODE, keySpec);
            byte[] data = cipher.doFinal(input.getBytes(CHARSET));
            return Base64.getEncoder().encodeToString(data);
        }
    
        /**
         * 解密
         *
         * @param input 密文
         * @param key   密钥
         * @return 明文
         * @throws GeneralSecurityException
         */
        public static String decrypt(String input, String key) throws GeneralSecurityException {
        
            Cipher cipher = Cipher.getInstance(AES);
            SecretKey keySpec = new SecretKeySpec(key.getBytes(CHARSET), AES);
            cipher.init(Cipher.DECRYPT_MODE, keySpec);
            byte[] data = cipher.doFinal(Base64.getDecoder().decode(input));
            return new String(data, CHARSET);
        }
    
        public static void main(String[] args) throws GeneralSecurityException {
        
            String msg = "我喜欢你，可以做我女朋友吗？";
            String key = "One-More12345678One.More87654321";
            System.out.println("加密前：" + msg);
            String pwd = AesUtil.encrypt(msg, key);
            System.out.println("加密后：" + pwd);
            System.out.println("解密后：" + AesUtil.decrypt(pwd, key));
        }
    }

运行结果如下：

加密前：我喜欢你，可以做我女朋友吗？
    加密后：dT29xX+XpPTO3OMuDw1ASyU/+aNfJ1K+endNUJ84h2KZhqRDNfiO4hAQjOXMCoN4
    解密后：我喜欢你，可以做我女朋友吗？

**AES算法是目前应用最广泛的对称加密算法。**

#### 总结 ####

对称加密算法在加密和解密时使用的密钥相同，常见的对称加密算法有：DES算法、3DES算法、AES算法。  
由于安全性低、加密解密效率低，DES算法和3DES算法是不推荐使用的，AES算法是目前应用最广泛的对称加密算法。