【数据加密】对称加密，非对称加密，摘要加密。三种加密方式的解释以及用途。Java代码实现SM3，SM4，AES，DES工具类_3、对称密码、非对称密码、报文摘要这三种密码学技术,分别描述其特点和用途,并至

数据加密：

加密分为三种：

1. 对称加密（symmetric），例如：AES、DES等
2. 非对称加密（asymmetric），例如：RSA、DSA等
3. 摘要加密（digest），例如：MD5、SHA-1、SHA-256、HMAC等

1. 对称加密（Symmetric Encryption）

意思：对称加密是一种加密方法，它使用相同的密钥进行数据的加密和解密。这意味着发送方和接收方必须共享同一个密钥，并且在通信之前确保这个密钥的安全传输。

解释：因为加解密使用的是同一把“钥匙”，所以这种加密方式相对简单高效，适合处理大量数据的加密。然而，密钥的安全分发是一个挑战，一旦密钥泄露，加密信息就可能被破解。

用途：对称加密广泛应用于数据存储、文件加密、网络通信等领域，比如AES（高级加密标准）常用于无线网络通信加密、银行交易数据保护等。

2. 非对称加密（Asymmetric Encryption）

意思：非对称加密采用了两个密钥，分别是公钥和私钥。公钥可以公开，用于加密信息；私钥必须保密，用于解密信息。知道公钥并不能推算出私钥，这保证了信息的安全性。

解释：非对称加密的优势在于解决了密钥分发的问题，因为公钥可以公开传播，而私钥由接收方安全保管。这种方式虽然安全，但由于加密和解密过程更为复杂，处理速度较慢，通常不直接用于大量数据的加密，而是用于加密小量数据如密钥交换、数字签名等场景。

用途：非对称加密常用于SSL/TLS协议中的网站安全连接、SSH远程登录、电子邮件加密（如PGP）、数字签名和身份认证等。

3. 摘要加密（Digest，通常称为哈希函数或散列函数）

意思：摘要加密实际上并不属于传统意义上的加密，因为它不可逆，即从摘要不能还原出原始信息。它将任意长度的输入（消息）转换为固定长度的输出（摘要或哈希值），目的是验证数据的完整性和唯一性。

解释：哈希函数具有抗碰撞性，即不同输入很难得到相同的输出。即便输入信息只改变一点点，输出的哈希值也会完全不同。这种特性使得摘要加密非常适合用于数据校验、密码存储和数字签名等场景。

用途：

• 数据校验：确保数据在传输过程中没有被篡改。
• 密码存储：存储用户密码时，不直接存储明文密码，而是存储密码的哈希值，增加安全性。
• 数字签名：结合非对称加密，发送方可以用私钥对消息的哈希值进行加密形成数字签名，接收方使用公钥验证签名真伪，以此确认消息来源和完整性。

每种加密方式都有其独特的应用场景和优势，实际中往往结合使用，以达到既高效又安全的目的。

糊涂工具对上诉加密提供了实现：
https://doc.hutool.cn/pages/crypto/index/

加密工具类

SM3 加密
SM3是一种由中国国家密码管理局制定的密码散列函数标准，类似于SHA-256，用于生成一个固定长度的摘要。SM3的设计目标是提供与国际标准相当的安全强度，同时满足中国国内的信息安全需求。SM3的输出长度为256位，它基于Merkle-Damgård结构，采用了一种称为Piling-up Lemma的扩散技术，以增强算法的安全性。

SM4 加密
SM4是中国国家密码管理局发布的分组密码算法，它是一种对称加密算法，类似于AES（Advanced Encryption Standard）。SM4设计用于多种应用场景，包括但不限于数据加密、消息认证码（MAC）生成和随机数生成。SM4的工作模式包括ECB（电子密码本）、CBC（密码块链接）、CFB（密码反馈）和OFB（输出反馈）。

AES（Advanced Encryption Standard，高级加密标准）
AES是目前广泛使用的一种对称加密算法，由比利时密码学家Joan Daemen和Vincent Rijmen设计，最初被称为Rijndael。2001年，美国国家标准与技术研究院（NIST）正式采纳AES作为联邦信息处理标准（FIPS PUB 197），用于替换旧的DES加密标准。

特点：

• 密钥长度：AES支持128位、192位和256位的密钥长度，这使得它比DES更安全，因为密钥空间更大，暴力破解的难度显著增加。
• 分组大小：AES的分组大小固定为128位。
• 加密过程：AES采用了基于字节的替换、行移位、列混淆和轮密钥加法等复杂操作，这些操作在每一轮加密中都会进行，轮数取决于密钥长度（128位密钥10轮，192位密钥12轮，256位密钥14轮）。
• 安全性：AES目前被认为是安全的，没有已知的有效攻击能够在合理时间内破解其完整版本。

DES（Data Encryption Standard，数据加密标准）
DES是一种早期的对称加密算法，由IBM开发，并在1977年被美国国家标准局（现NIST）采纳为官方标准。DES曾是全球最广泛使用的加密算法之一，但在21世纪初，由于其密钥长度仅为56位，开始显露出安全性不足的问题。

特点：

• 密钥长度：DES的密钥长度为56位，但由于DES算法中使用了64位密钥，其中8位用于奇偶校验，实际上可用的密钥长度为56位。
• 分组大小：DES的分组大小为64位。
• 加密过程：DES使用Feistel网络结构，每一轮加密都将64位的输入数据分为两半，对其中一半进行一系列的置换、扩展、替换和XOR运算，然后与轮密钥结合，再与另一半数据进行XOR操作，最终两半数据重新组合。
• 安全性：由于密钥长度较短，DES现在容易受到暴力破解攻击。为提高安全性，产生了三重DES（3DES），通过使用两个或三个独立的DES密钥对同一数据进行三次加密，但3DES的效率低于AES。

AES和DES都是对称加密算法，但AES在安全性、性能和密钥长度方面都优于DES，因此AES已经成为现代加密应用的首选标准。DES在历史上占有重要地位，但如今在安全性要求较高的场合已被AES所取代。

1. Sm3Utils

package cn.creatoo.why.util;

import org.bouncycastle.crypto.digests.SM3Digest;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.bouncycastle.pqc.math.linearalgebra.ByteUtils;

import java.io.UnsupportedEncodingException;
import java.security.Security;
import java.util.Arrays;

/**
 * SM3 工具类
 */
public class Sm3Utils {

    /**
     * 编码格式
     */
    private static final String ENCODING = "UTF-8";

    static {
        Security.addProvider(new BouncyCastleProvider());
    }

    /**
     * @param paramStr 要sm3加密的内容
     * @return sm3加密后密文
     */
    public static String encrypt(String paramStr) {
        String resultHexString = "";
        try {
            byte[] srcData = paramStr.getBytes(ENCODING);
            byte[] hash = hash(srcData);
            resultHexString = ByteUtils.toHexString(hash);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return resultHexString;
    }

    public static byte[] hash(byte[] srcData) {
        SM3Digest sm3Digest = new SM3Digest();
        sm3Digest.update(srcData, 0, srcData.length);
        byte[] bytes = new byte[sm3Digest.getDigestSize()];
        sm3Digest.doFinal(bytes, 0);
        return bytes;
    }

    /**
     * @param str       明文
     * @param hexString 密文
     * @return 明文密文对比结果
     */
    public static boolean verify(String str, String hexString) {
        boolean flag = false;
        try {
            byte[] srcData = str.getBytes(ENCODING);
            byte[] sm3Hash = ByteUtils.fromHexString(hexString);
            byte[] hash = hash(srcData);
            if (Arrays.equals(hash, sm3Hash)) {
                flag = true;
            }
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return flag;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

2. SM4Util

package cn.creatoo.why.util;

import org.bouncycastle.jce.provider.BouncyCastleProvider;

import java.security.Key;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.SecureRandom;
import java.security.Security;
import java.util.Arrays;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.spec.SecretKeySpec;

import org.bouncycastle.pqc.math.linearalgebra.ByteUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import java.security.Security;

/**
 * sm4加密算法工具类
 *
 * @explain sm4加密、解密与加密结果验证
 * 可逆算法
 */
@Component
public class SM4Util {
	// 一串字符串如：KA34D430ERER45K899X9987M90A6L76A
    @Value("${dataSync.sm4Secret}")
    private String key;

    static {
        Security.addProvider(new BouncyCastleProvider());
    }

    private static final String ENCODING = "UTF-8";
    public static final String ALGORITHM_NAME = "SM4";
    // 加密算法/分组加密模式/分组填充方式
    // PKCS5Padding-以8个字节为一组进行分组加密
    // 定义分组加密模式使用：PKCS5Padding
    public static final String ALGORITHM_NAME_ECB_PADDING = "SM4/ECB/PKCS5Padding";
    // 128-32位16进制；256-64位16进制
    public static final int DEFAULT_KEY_SIZE = 128;

    /**
     * 生成ECB暗号
     *
     * @param algorithmName 算法名称
     * @param mode          模式
     * @param key
     * @return
     * @throws Exception
     * @explain ECB模式（电子密码本模式：Electronic codebook）
     */
    private static Cipher generateEcbCipher(String algorithmName, int mode, byte[] key) throws Exception {
        Cipher cipher = Cipher.getInstance(algorithmName, BouncyCastleProvider.PROVIDER_NAME);
        Key sm4Key = new SecretKeySpec(key, ALGORITHM_NAME);
        cipher.init(mode, sm4Key);
        return cipher;
    }

    /**
     * 自动生成密钥
     *
     * @return
     * @throws NoSuchAlgorithmException
     * @throws NoSuchProviderException
     * @explain
     */
    public static byte[] generateKey() throws Exception {
        return generateKey(DEFAULT_KEY_SIZE);
    }

    /**
     * @param keySize
     * @return
     * @throws Exception
     * @explain
     */
    public static byte[] generateKey(int keySize) throws Exception {
        KeyGenerator kg = KeyGenerator.getInstance(ALGORITHM_NAME, BouncyCastleProvider.PROVIDER_NAME);
        kg.init(keySize, new SecureRandom());
        return kg.generateKey().getEncoded();
    }

    /**
     * sm4加密
     *
     * @param paramStr 待加密字符串
     * @return 返回16进制的加密字符串
     * @throws Exception
     * @explain 加密模式：ECB
     * 密文长度不固定，会随着被加密字符串长度的变化而变化
     * 16进制密钥（忽略大小写）
     */
    public String encrypt(String paramStr) throws Exception {
        String cipherText = "";
        // 16进制字符串-->byte[]
        byte[] keyData = ByteUtils.fromHexString(key);
        // String-->byte[]
        byte[] srcData = paramStr.getBytes(ENCODING);
        // 加密后的数组
        byte[] cipherArray = encrypt_Ecb_Padding(keyData, srcData);
        // byte[]-->hexString
        cipherText = ByteUtils.toHexString(cipherArray);
        return cipherText;
    }

    /**
     * 加密模式之Ecb
     *
     * @param key
     * @param data
     * @return
     * @throws Exception
     * @explain
     */
    public static byte[] encrypt_Ecb_Padding(byte[] key, byte[] data) throws Exception {
        Cipher cipher = generateEcbCipher(ALGORITHM_NAME_ECB_PADDING, Cipher.ENCRYPT_MODE, key);
        return cipher.doFinal(data);
    }

    /**
     * sm4解密
     *
     * @param cipherText 16进制的加密字符串（忽略大小写）
     * @return 解密后的字符串
     * @throws Exception
     * @explain 解密模式：采用ECB
     * 16进制密钥
     */
    public String decryptEcb(String cipherText) throws Exception {
        // 用于接收解密后的字符串
        String decryptStr = "";
        // hexString-->byte[]
        byte[] keyData = ByteUtils.fromHexString(key);
        // hexString-->byte[]
        byte[] cipherData = ByteUtils.fromHexString(cipherText);
        // 解密
        byte[] srcData = decrypt_Ecb_Padding(keyData, cipherData);
        // byte[]-->String
        decryptStr = new String(srcData, ENCODING);
        return decryptStr;
    }

    /**
     * 解密
     *
     * @param key
     * @param cipherText
     * @return
     * @throws Exception
     * @explain
     */
    public static byte[] decrypt_Ecb_Padding(byte[] key, byte[] cipherText) throws Exception {
        Cipher cipher = generateEcbCipher(ALGORITHM_NAME_ECB_PADDING, Cipher.DECRYPT_MODE, key);
        return cipher.doFinal(cipherText);
    }

    /**
     * 校验加密前后的字符串是否为同一数据
     *
     * @param cipherText 16进制加密后的字符串
     * @param paramStr   加密前的字符串
     * @return 是否为同一数据
     * @throws Exception
     * @explain 16进制密钥（忽略大小写）
     */
    public boolean verifyEcb(String cipherText, String paramStr) throws Exception {
        // 用于接收校验结果
        boolean flag = false;
        // hexString-->byte[]
        byte[] keyData = ByteUtils.fromHexString(key);
        // 将16进制字符串转换成数组
        byte[] cipherData = ByteUtils.fromHexString(cipherText);
        // 解密
        byte[] decryptData = decrypt_Ecb_Padding(keyData, cipherData);
        // 将原字符串转换成byte[]
        byte[] srcData = paramStr.getBytes(ENCODING);
        // 判断2个数组是否一致
        flag = Arrays.equals(decryptData, srcData);
        return flag;
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186

3. ADCryptUtils

import com.sun.org.apache.xerces.internal.impl.dv.util.Base64;
import org.bouncycastle.jce.provider.BouncyCastleProvider;

import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.security.Security;

public class ADCryptUtils {

    static { try { Security.addProvider(new BouncyCastleProvider()); } catch (Exception e) { e.printStackTrace(); } }

    // vi 076ce634d7da11eb
    private static final byte[] DES_DEFAULT_KEY=new byte[] { 10, 20, 50, 99, 101, 54, 51, 52, 100, 55, 100, 97, 49, 49, 112, 98 };
    private static final byte[] AES_DEFAULT_KEY=new byte[] { 10, 20, 50, 99, 101, 54, 51, 52, 100, 55, 100, 97, 49, 49, 112, 98 };


    /**
     * content: 加密内容
     */
    public static String encryptAes(String content) throws Exception {
        Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
        SecretKey secretKey = new SecretKeySpec(AES_DEFAULT_KEY, "AES");
        cipher.init(Cipher.ENCRYPT_MODE, secretKey,new IvParameterSpec(AES_DEFAULT_KEY));
        byte[] encrypted = cipher.doFinal(content.getBytes());
        return Base64.encode(encrypted);
    }
    /**
     * content: 解密内容
     */
    public static String decryptAes(String base64Content) throws Exception {
        Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
        SecretKey secretKey = new SecretKeySpec(AES_DEFAULT_KEY, "AES");
        cipher.init(Cipher.DECRYPT_MODE, secretKey,new IvParameterSpec(AES_DEFAULT_KEY));
        byte[] content = Base64.decode(base64Content);
        byte[] encrypted = cipher.doFinal(content);
        return new String(encrypted);
    }
    /**
     * content: 加密内容
     */
    public static String encryptDes(String content) throws Exception {
        Cipher cipher = Cipher.getInstance("DES");
        SecretKey secretKey = new SecretKeySpec(DES_DEFAULT_KEY, "DES");
        cipher.init(Cipher.ENCRYPT_MODE, secretKey);
        byte[] encrypted = cipher.doFinal(content.getBytes());
        return Base64.encode(encrypted);
    }
    /**
     * content: 解密内容
     */
    public static String decryptDes(String base64Content) throws Exception {
        Cipher cipher = Cipher.getInstance("DES");
        SecretKey secretKey = new SecretKeySpec(DES_DEFAULT_KEY, "DES");
        cipher.init(Cipher.DECRYPT_MODE, secretKey);
        byte[] content = Base64.decode(base64Content);
        byte[] encrypted = cipher.doFinal(content);
        return new String(encrypted);
    }
    /**
     * content: 加密内容
     * slatKey: 加密的盐，16位字符串
     */
    public static String encryptAes(String content, String slatKey) throws Exception {
        Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
        SecretKey secretKey = new SecretKeySpec(slatKey.getBytes(), "AES");
        cipher.init(Cipher.ENCRYPT_MODE, secretKey,new IvParameterSpec(AES_DEFAULT_KEY));
        byte[] encrypted = cipher.doFinal(content.getBytes());
        return Base64.encode(encrypted);
    }
    /**
     * content: 解密内容
     * slatKey: 加密时使用的盐，16位字符串
     */
    public static String decryptAes(String base64Content, String slatKey) throws Exception {
        Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
        SecretKey secretKey = new SecretKeySpec(slatKey.getBytes(), "AES");
        cipher.init(Cipher.DECRYPT_MODE, secretKey,new IvParameterSpec(AES_DEFAULT_KEY));
        byte[] content = Base64.decode(base64Content);
        byte[] encrypted = cipher.doFinal(content);
        return new String(encrypted);
    }
    /**
     * content: 加密内容
     * slatKey: 加密的盐，16位字符串
     * vectorKey: 加密的向量，16位字符串
     */
    public static String encryptAes(String content, String slatKey, String vectorKey) throws Exception {
        Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
        SecretKey secretKey = new SecretKeySpec(slatKey.getBytes(), "AES");
        IvParameterSpec iv = new IvParameterSpec(vectorKey.getBytes());
        cipher.init(Cipher.ENCRYPT_MODE, secretKey, iv);
        byte[] encrypted = cipher.doFinal(content.getBytes());
        return Base64.encode(encrypted);
    }
    /**
     * content: 解密内容(base64编码格式)
     * slatKey: 加密时使用的盐，16位字符串
     * vectorKey: 加密时使用的向量，16位字符串
     */
    public static String decryptAes(String base64Content, String slatKey, String vectorKey) throws Exception {
        Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
        SecretKey secretKey = new SecretKeySpec(slatKey.getBytes(), "AES");
        IvParameterSpec iv = new IvParameterSpec(vectorKey.getBytes());
        cipher.init(Cipher.DECRYPT_MODE, secretKey, iv);
        byte[] content = Base64.decode(base64Content);
        byte[] encrypted = cipher.doFinal(content);
        return new String(encrypted);
    }
    /**
     * content: 加密内容
     * slatKey: 加密的盐，8位字符串
     */
    public static String encryptDes(String content, String slatKey) throws Exception {
        Cipher cipher = Cipher.getInstance("DES");
        SecretKey secretKey = new SecretKeySpec(slatKey.getBytes(), "DES");
        cipher.init(Cipher.ENCRYPT_MODE, secretKey);
        byte[] encrypted = cipher.doFinal(content.getBytes());
        return Base64.encode(encrypted);
    }
    /**
     * content: 解密内容
     * slatKey: 加密时使用的盐，8位字符串
     */
    public static String decryptDes(String base64Content, String slatKey) throws Exception {
        Cipher cipher = Cipher.getInstance("DES");
        SecretKey secretKey = new SecretKeySpec(slatKey.getBytes(), "DES");
        cipher.init(Cipher.DECRYPT_MODE, secretKey);
        byte[] content = Base64.decode(base64Content);
        byte[] encrypted = cipher.doFinal(content);
        return new String(encrypted);
    }

    public static void main(String[] args) {
        try {
            String encryptDes = ADCryptUtils.encryptAes("测试AES加密");
            System.out.println(encryptDes);
            String decryptDes = ADCryptUtils.decryptAes(encryptDes);
            System.out.println(decryptDes);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145