DES对称加密（附工具类Util）

╰+哭是因爲堅強的太久メ 2023-09-27 17:03 113阅读 0赞

#### 文章目录 ####

*  什么是对称加密
 *  加密算法

--------------------

**一、什么是对称加密？**

对称加密指的就是加密和解密使用同一个秘钥的加密方式。对称加密只有一个秘钥，作为私钥。

常见的对称加密算法：DES，AES，3DES等等。

![4607623e12204a9ab01a582475af2f0d.jpeg][]

## 二、加密算法（DES） ##

今天主要讲的是**DES**加密算法。

**1、什么是DES算法？**

DES（Data Encryption Standard，即数据加密标准），是一种使用密钥加密的块算法，1977年被美国联邦政府的国家标准局确定为联邦资料处理标准（FIPS），并授权在非密级政府通信中使用，随后该算法在国际上广泛流传开来。

**2、DES算法是怎么加密的？**

DES是将明文按64位进行分组，密钥长64位，密钥是利用56+8奇偶校验位（第8,16,24,32,40,48,56,64）=64位的密钥对以64位为单位的块数据进行加解密。参与DES运算（第8、16、24、32、40、48、56、64位是校验位， 使得每个密钥都有奇数个1）分组后的明文组和56位的密钥按位替代或交换的方法形成密文组。

DES算法的加密密钥是根据用户输入的密码生成的,该算法把64位密码中的第8位、第16位、第24位、第32位、第40位、第48位、第56位、第64位作为奇偶校验位,在计算密钥时要忽略这8位.如果输入的密码只是在这8位上有区别的话,那么操作后的结果将是一样的。

DES是一种对称密码，加密过程和解密过程使用相同的密钥。DES是一种迭代算法。DES对明文中的每个分组的加密都包含16轮，且每轮的操作完全相同。每轮都会使用不同的子密钥，并且子密钥Ki都从主密钥推导而来。

**直接上代码：**

**DESUtil**：

import org.apache.tomcat.util.codec.binary.Base64;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.security.Key;
    import java.security.NoSuchAlgorithmException;
    import java.security.SecureRandom;
    import java.security.spec.AlgorithmParameterSpec;
    import javax.crypto.Cipher;
    import javax.crypto.CipherInputStream;
    import javax.crypto.CipherOutputStream;
    import javax.crypto.KeyGenerator;
    import javax.crypto.spec.IvParameterSpec;
     
        /**
         * DES加密算法工具类
         */
        public class DESUtil {
    
        /**
         * CFB
         */
        public static final String CFB = "CFB";
    
        /**
         * OFB
         */
        public static final String OFB = "OFB";
    
        /**
         * CBC
         */
        public static final String CBC = "CBC";
    
        /**
         * iv向量
         */
        private static final byte[] DESIV = {(byte) 0xCE, (byte) 0x35, (byte) 0x5,
                (byte) 0xD, (byte) 0x98, (byte) 0x91, (byte) 0x8, (byte) 0xA};
    
        /**
         * AlgorithmParameterSpec
         */
        private static AlgorithmParameterSpec IV = null;
    
        /**
         * SHA1PRNG
         */
        private static final String SHA1PRNG = "SHA1PRNG";
    
        /**
         * DES默认模式
         */
        private static final String DES = "DES";
    
        /**
         * CBC加密模式
         */
        private static final String DES_CBC_PKCS5PADDING = "DES/CBC/PKCS5Padding";
    
        /**
         * OFB加密模式
         */
        private static final String DES_OFB_PKCS5PADDING = "DES/OFB/PKCS5Padding";
    
        /**
         * CFB加密模式
         */
        private static final String DES_CFB_PKCS5_PADDING = "DES/CFB/PKCS5Padding";
    
        /**
         * 加密模式
         */
        private static final int ENCRYPT_MODE = 1;
    
        /**
         * 解密模式
         */
        private static final int DECRYPT_MODE = 2;
    
        /**
         * 密钥
         */
        private Key key;
    
        public DesUtil(String str) {
            getKey(str);
        }
    
        public Key getKey() {
            return key;
        }
    
        public void setKey(Key key) {
            this.key = key;
        }
    
        /**
         * 通过密钥获得key
         *
         * @param secretKey 密钥
         */
        public void getKey(String secretKey) {
            try {
                SecureRandom secureRandom = SecureRandom.getInstance(SHA1PRNG);
                secureRandom.setSeed(secretKey.getBytes());
                KeyGenerator generator;
                try {
                    generator = KeyGenerator.getInstance(DES);
                    generator.init(secureRandom);
                    IV = new IvParameterSpec(DESIV);
                    this.key = generator.generateKey();
                } catch (NoSuchAlgorithmException e) {
                    e.printStackTrace();
                }
            } catch (Exception e) {
                throw new RuntimeException("Error in getKey(String secretKey), Cause: " + e);
            }
        }
    
        /**
         * 字符串des加密
         *
         * @param data        需要加密的字符串
         * @param encryptType 加密模式 (ECB/CBC/OFB/CFB)
         * @return 加密结果
         * @throws Exception 异常
         */
        public String encrypt(String data, String encryptType) throws Exception {
            Cipher cipher = getPattern(encryptType, ENCRYPT_MODE);
            byte[] pasByte = cipher.doFinal(data.getBytes(StandardCharsets.UTF_8));
            return Base64.encodeBase64String(pasByte);
        }
    
        /**
         * 字符串des解密
         *
         * @param data        需要解密的字符串
         * @param decryptType 解密模式 (ECB/CBC/OFB/CFB)
         * @return 解密结果
         * @throws Exception 异常
         */
        public String decrypt(String data, String decryptType) throws Exception {
            Cipher cipher = getPattern(decryptType, DECRYPT_MODE);
            byte[] pasByte = cipher.doFinal(Base64.decodeBase64(data));
            return new String(pasByte, StandardCharsets.UTF_8);
        }
    
        /**
         * 初始化cipher
         *
         * @param type       加密/解密模式 (ECB/CBC/OFB/CFB)
         * @param cipherMode cipher工作模式 1：加密； 2：解密
         * @return cipher
         * @throws Exception 异常
         */
        private Cipher getPattern(String type, int cipherMode) throws Exception {
            Cipher cipher;
            switch (type) {
                case CBC:
                    cipher = Cipher.getInstance(DES_CBC_PKCS5PADDING);
                    cipher.init(cipherMode, key, IV);
                    break;
                case OFB:
                    cipher = Cipher.getInstance(DES_OFB_PKCS5PADDING);
                    cipher.init(cipherMode, key, IV);
                    break;
                case CFB:
                    cipher = Cipher.getInstance(DES_CFB_PKCS5_PADDING);
                    cipher.init(cipherMode, key, IV);
                    break;
                default:
                    cipher = Cipher.getInstance(DES);
                    cipher.init(cipherMode, key);
                    break;
            }
            return cipher;
        }
    
        /**
         * 文件 file 进行加密并保存目标文件 destFile 中
         *
         * @param file        要加密的文件 如 c:/test/file.txt
         * @param destFile    加密后存放的文件名 如 c:/ 加密后文件 .txt
         * @param encryptType 加密模式 (ECB/CBC/OFB/CFB)
         * @return 加密结果   0：异常 1：加密成功； 5：未找到需要加密的文件
         */
        public int encryptFile(String file, String destFile, String encryptType) {
            int result = 0;
            try {
                Cipher cipher = getPattern(encryptType, ENCRYPT_MODE);
                InputStream is = new FileInputStream(file);
                OutputStream out = new FileOutputStream(destFile);
                CipherInputStream cis = new CipherInputStream(is, cipher);
                byte[] buffer = new byte[1024];
                int r;
                while ((r = cis.read(buffer)) > 0) {
                    out.write(buffer, 0, r);
                }
                cis.close();
                is.close();
                out.close();
                result = 1;
            } catch (FileNotFoundException e) {
                result = 5;
            } catch (Exception e) {
                e.printStackTrace();
            }
            return result;
        }
    
        /**
         * 文件 file 进行解密并保存目标文件 destFile 中
         *
         * @param file        要解密的文件 如 c:/test/file.txt
         * @param destFile    解密后存放的文件名 如 c:/ 解密后文件 .txt
         * @param decryptType 解密模式 (ECB/CBC/OFB/CFB)
         * @return 解密结果 0：解密异常；1：解密正常；5：未找到需要解密的文件
         */
        public int decryptFile(String file, String destFile, String decryptType) {
            int result = 0;
            try {
                Cipher cipher = getPattern(decryptType, DECRYPT_MODE);
                InputStream is = new FileInputStream(file);
                OutputStream out = new FileOutputStream(destFile);
                CipherOutputStream cos = new CipherOutputStream(out, cipher);
                byte[] buffer = new byte[1024];
                int r;
                while ((r = is.read(buffer)) >= 0) {
                    cos.write(buffer, 0, r);
                }
                cos.close();
                out.close();
                is.close();
                result = 1;
            } catch (FileNotFoundException e) {
                result = 5;
            } catch (Exception e) {
                e.printStackTrace();
            }
            return result;
        }
    }

写个测试的main方法：

public static void main(String[] args) throws Exception {
    
            String testString = "HelloWorld";
            System.out.println("加密前：" + testString);
            String key = "ABCDEFGHIJK";
            DesUtil desUtil = new DesUtil(key);
    
            String encryptStr = desUtil.encrypt(testString, "CBC");
            System.out.println("加密后：" + encryptStr);
            String decryptStr = desUtil.decrypt(encryptStr, "CBC");
            System.out.println("解密后：" + decryptStr);
        }

结果：

![e5ec1d1169114ec0aa6d26e8d27bb4d6.jpeg][]

#### 如果这篇文章对您有所帮助，或者有所启发的话，求一键三连：点赞、评论、收藏➕关注，您的支持是我坚持写作最大的动力。 ####

##  ##

[4607623e12204a9ab01a582475af2f0d.jpeg]: https://img-blog.csdnimg.cn/4607623e12204a9ab01a582475af2f0d.jpeg
[e5ec1d1169114ec0aa6d26e8d27bb4d6.jpeg]: https://img-blog.csdnimg.cn/e5ec1d1169114ec0aa6d26e8d27bb4d6.jpeg