加密与安全_解密AES加密中的IV和Seed

---

概述

在AES加密中，**IV（Initialization Vector，初始化向量）和Seed（种子）**是两个差异的概念，尽管它们都涉及到随机性和加密安全性，但用途和作用有所差异。
IV（Initialization Vector，初始化向量）

• 用途：IV 是在加密块模式（如 CBC, CFB, OFB, 等）中使用的一个随机或伪随机的输入值。它确保相同的明文在加密时产生差异的密文，从而增强了加密的安全性。
  
• 特点：
  
  
  
  • IV 通常是一个固定长度的随机数，长度与加密算法的块大小相同（比方，对于AES，IV长度为128位，即16字节）。
    
  • 在加密过程中，IV 通常与明文的第一个块举行某种形式的操作（如异或）来产生第一个加密块。后续块则依靠于前一个加密块。
    
  • IV 不需要保密，但要确保每次加密都不相同，以防止模式分析攻击。
    
  
  

Seed（种子）

• 用途：Seed 通常用于天生随机数或伪随机数。在加密算法中，随机数天生器需要一个初始值，Seed 用来设置这个初始状态，以便天生一系列的伪随机数。
  
• 特点：
  
  
  
  • Seed 可以是一个恣意长度的数值，用于初始化随机数天生器（如在密钥天生、随机添补、天生IV等场景中使用）。
    
  • 使用相同的 Seed 初始化同一个随机数天生器，将天生相同的伪随机数序列。因此，Seed 的选取应尽量多样化和随机化，以避免天生可预测的随机数序列。
    
  
  

---

Code

seed

2. import org.apache.commons.codec.DecoderException;
3. import org.apache.commons.codec.binary.Hex;
5. import javax.crypto.BadPaddingException;
6. import javax.crypto.Cipher;
7. import javax.crypto.IllegalBlockSizeException;
8. import javax.crypto.KeyGenerator;
9. import javax.crypto.NoSuchPaddingException;
10. import javax.crypto.SecretKey;
11. import javax.crypto.spec.SecretKeySpec;
12. import java.security.InvalidKeyException;
13. import java.security.NoSuchAlgorithmException;
14. import java.security.SecureRandom;
15. import java.util.UUID;
17. /**
18. * AES 对称性加密
19. * <p>
20. * 需要依赖 Apache Commons Codec
21. *
22. * @author artisan
23. */
24. public class AesUtil {
26.     /**
27.      * 加密算法类型
28.      */
29.     static final String ALGORITHM_KEY = "AES";
31.     /**
32.      * 算法长度
33.      */
34.     private static final int KEY_SIZE = 128;
37.     /**
38.      * 生成一个种子字符串
39.      * 该方法通过生成一个唯一标识符（UUID）来创建一个唯一的种子字符串
40.      * 使用UUID可以确保生成的种子在一定范围内具有唯一性
41.      *
42.      * @return 返回一个UUID作为种子字符串
43.      */
44.     public static String generateSeed() {
45.         return UUID.randomUUID().toString();
46.     }
49.     /**
50.      * 使用 种子（密码）、模式 创建密码加密
51.      *
52.      * @param seed 种子（密码）
53.      * @param mode 模式，加密：{@link Cipher#ENCRYPT_MODE}，解密：{@link Cipher#DECRYPT_MODE}
54.      * @return 返回 密码加密
55.      * @throws NoSuchAlgorithmException 算法类型异常
56.      * @throws NoSuchPaddingException   算法填充异常
57.      * @throws InvalidKeyException      无效的密钥异常
58.      */
59.     public static Cipher cipher(String seed, int mode) throws NoSuchAlgorithmException,
60.             NoSuchPaddingException, InvalidKeyException {
61.         KeyGenerator keyGenerator = KeyGenerator.getInstance(ALGORITHM_KEY);
62.         byte[] seedBytes = seed.getBytes();
63.         keyGenerator.init(KEY_SIZE, new SecureRandom(seedBytes));
64.         SecretKey secretKey = keyGenerator.generateKey();
65.         byte[] encodedBytes = secretKey.getEncoded();
66.         SecretKeySpec secretKeySpec = new SecretKeySpec(encodedBytes, ALGORITHM_KEY);
67.         Cipher cipher = Cipher.getInstance(ALGORITHM_KEY);
68.         cipher.init(mode, secretKeySpec);
69.         return cipher;
70.     }
72.     /**
73.      * 使用 种子（密码）将内容 加密
74.      *
75.      * @param originalText 原文
76.      * @param seed         种子（密码）
77.      * @return 返回 加密结果
78.      * @throws NoSuchAlgorithmException  算法类型异常
79.      * @throws NoSuchPaddingException    算法填充异常
80.      * @throws InvalidKeyException       无效的密钥异常
81.      * @throws BadPaddingException       错误填充异常
82.      * @throws IllegalBlockSizeException 非法的块大小异常
83.      */
84.     public static byte[] encrypt(byte[] originalText, String seed) throws NoSuchAlgorithmException, NoSuchPaddingException,
85.             InvalidKeyException, BadPaddingException, IllegalBlockSizeException {
86.         Cipher cipher = cipher(seed, Cipher.ENCRYPT_MODE);
87.         return cipher.doFinal(originalText);
88.     }
90.     /**
91.      * 使用 种子（密码）将内容 加密
92.      *
93.      * @param originalText 原文
94.      * @param seed         种子（密码）
95.      * @return 返回 加密结果
96.      * @throws NoSuchAlgorithmException  算法类型异常
97.      * @throws NoSuchPaddingException    算法填充异常
98.      * @throws InvalidKeyException       无效的密钥异常
99.      * @throws BadPaddingException       错误填充异常
100.      * @throws IllegalBlockSizeException 非法的块大小异常
101.      */
102.     public static byte[] encrypt(String originalText, String seed) throws NoSuchAlgorithmException, NoSuchPaddingException,
103.             InvalidKeyException, BadPaddingException, IllegalBlockSizeException {
104.         return encrypt(originalText.getBytes(), seed);
105.     }
107.     /**
108.      * 使用 种子（密码）将内容 加密
109.      *
110.      * @param originalText 原文
111.      * @param seed         种子（密码）
112.      * @return 返回 加密结果
113.      * @throws NoSuchAlgorithmException  算法类型异常
114.      * @throws NoSuchPaddingException    算法填充异常
115.      * @throws InvalidKeyException       无效的密钥异常
116.      * @throws BadPaddingException       错误填充异常
117.      * @throws IllegalBlockSizeException 非法的块大小异常
118.      */
119.     public static String encryptStr(String originalText, String seed) throws NoSuchAlgorithmException, NoSuchPaddingException,
120.             InvalidKeyException, BadPaddingException, IllegalBlockSizeException {
121.         byte[] encryptBytes = encrypt(originalText.getBytes(), seed);
122.         return Hex.encodeHexString(encryptBytes);
123.     }
125.     /**
126.      * 使用 种子（密码）将内容 解密
127.      *
128.      * @param cipherText 密文
129.      * @param seed       种子（密码）
130.      * @return 返回 解密原文
131.      * @throws NoSuchAlgorithmException  算法类型异常
132.      * @throws NoSuchPaddingException    算法填充异常
133.      * @throws InvalidKeyException       无效的密钥异常
134.      * @throws BadPaddingException       错误填充异常
135.      * @throws IllegalBlockSizeException 非法的块大小异常
136.      */
137.     public static byte[] decrypt(byte[] cipherText, String seed) throws NoSuchAlgorithmException, BadPaddingException,
138.             IllegalBlockSizeException, NoSuchPaddingException, InvalidKeyException {
139.         Cipher cipher = cipher(seed, Cipher.DECRYPT_MODE);
140.         return cipher.doFinal(cipherText);
141.     }
143.     /**
144.      * 使用 种子（密码）将内容 解密
145.      *
146.      * @param cipherText 密文
147.      * @param seed       种子（密码）
148.      * @return 返回 解密原文
149.      * @throws NoSuchAlgorithmException  算法类型异常
150.      * @throws NoSuchPaddingException    算法填充异常
151.      * @throws InvalidKeyException       无效的密钥异常
152.      * @throws BadPaddingException       错误填充异常
153.      * @throws IllegalBlockSizeException 非法的块大小异常
154.      * @throws DecoderException          解码器异常
155.      */
156.     public static byte[] decrypt(String cipherText, String seed) throws NoSuchAlgorithmException, BadPaddingException,
157.             IllegalBlockSizeException, NoSuchPaddingException, InvalidKeyException, DecoderException {
158.         byte[] contentBytes = Hex.decodeHex(cipherText);
159.         return decrypt(contentBytes, seed);
160.     }
162.     /**
163.      * 使用 种子（密码）将内容 解密
164.      *
165.      * @param cipherText 密文
166.      * @param seed       种子（密码）
167.      * @return 返回 解密原文
168.      * @throws NoSuchAlgorithmException  算法类型异常
169.      * @throws NoSuchPaddingException    算法填充异常
170.      * @throws InvalidKeyException       无效的密钥异常
171.      * @throws BadPaddingException       错误填充异常
172.      * @throws IllegalBlockSizeException 非法的块大小异常
173.      * @throws DecoderException          解码器异常
174.      */
175.     public static String decryptStr(String cipherText, String seed) throws NoSuchAlgorithmException, BadPaddingException,
176.             IllegalBlockSizeException, NoSuchPaddingException, InvalidKeyException, DecoderException {
177.         byte[] decryptFrom = Hex.decodeHex(cipherText);
178.         byte[] decryptBytes = decrypt(decryptFrom, seed);
179.         return new String(decryptBytes);
180.     }
182. }

复制代码

测试代码

2. import org.apache.commons.codec.DecoderException;
3. import org.apache.commons.codec.binary.Hex;
4. import org.junit.jupiter.api.Test;
6. import javax.crypto.BadPaddingException;
7. import javax.crypto.IllegalBlockSizeException;
8. import javax.crypto.NoSuchPaddingException;
9. import java.security.InvalidKeyException;
10. import java.security.NoSuchAlgorithmException;
11. import java.util.UUID;
13. /**
14. * AES 对称加密 测试类
15. *
16. * @author artisan
17. */
18. public class AesUtils {
20.     /**
21.      * 生成一个种子字符串
22.      * 该方法通过生成一个唯一标识符（UUID）来创建一个唯一的种子字符串
23.      * 使用UUID可以确保生成的种子在一定范围内具有唯一性
24.      *
25.      * @return 返回一个UUID作为种子字符串
26.      */
27.     public static String generateSeed() {
28.         return UUID.randomUUID().toString();
29.     }
31.     /**
32.      * 字符串加密与解密
33.      */
34.     @Test
35.     public void string() throws IllegalBlockSizeException, InvalidKeyException, BadPaddingException,
36.             NoSuchAlgorithmException, NoSuchPaddingException, DecoderException {
38.         String content = "21dsikhjihiuseiu23isdjahjsfhuahfuiashufsdajiafjihaseuihfwauisdloa'aops][sogjier";
39.         String seed =  generateSeed();
40.         System.out.println(seed.length());
41.         System.out.println("原文：" + content);
42.         System.out.println("种子（密码）：" + seed);
44.         String encryptStr = Aes.encryptStr(content, seed);
45.         System.out.println("加密结果：" + encryptStr);
47.         String decryptStr = Aes.decryptStr(encryptStr, seed);
48.         System.out.println("解密结果：" + decryptStr);
49.     }
51.     /**
52.      * 字节与字符串
53.      */
54.     @Test
55.     public void byteAndString() throws IllegalBlockSizeException, InvalidKeyException, BadPaddingException,
56.             NoSuchAlgorithmException, NoSuchPaddingException, DecoderException {
57.         String content = "artisan go go go";
58.         String seed =  generateSeed();
60.         System.out.println("原文：" + content);
61.         System.out.println("种子（密码）：" + seed);
63.         byte[] encryptBytes = Aes.encrypt(content, seed);
64.         String encryptStr = Hex.encodeHexString(encryptBytes);
65.         System.out.println("加密结果：" + encryptStr);
67.         byte[] decryptBytes = Aes.decrypt(encryptStr, seed);
68.         System.out.println("解密结果：" + new String(decryptBytes));
69.     }
71.     /**
72.      * 字节
73.      */
74.     @Test
75.     public void bytes() throws IllegalBlockSizeException, InvalidKeyException, BadPaddingException,
76.             NoSuchAlgorithmException, NoSuchPaddingException, DecoderException {
77.         String content = "aedksej sdksfdkhoweio (*&*^&^^^";
78.         String seed = generateSeed();
80.         System.out.println("原文：" + content);
81.         System.out.println("种子（密码）：" + seed);
83.         byte[] encryptBytes = Aes.encrypt(content, seed);
84.         String encryptStr = Hex.encodeHexString(encryptBytes);
85.         System.out.println("加密结果：" + encryptStr);
87.         byte[] contentBytes = Hex.decodeHex(encryptStr);
88.         byte[] decryptBytes = Aes.decrypt(contentBytes, seed);
89.         System.out.println("解密结果：" + new String(decryptBytes));
90.     }
92. }

复制代码

---

IV

1. package com.artisan.shuangxiang_aesrsa;
3. import javax.crypto.Cipher;
4. import javax.crypto.SecretKey;
5. import javax.crypto.spec.IvParameterSpec;
6. import java.util.Base64;
8. /**
9. * AES工具类，提供AES加密和解密功能
10. * 使用AES/CBC/PKCS5Padding算法进行加密和解密
11. *
12. * @author artisan
13. */
14. public class AESUtil {
15.     /**
16.      * 定义加密算法类型为AES/CBC/PKCS5Padding
17.      */
18.     private static final String ALGORITHM = "AES/CBC/PKCS5Padding";
20.     /**
21.      * 使用AES算法加密数据
22.      *
23.      * @param data 待加密的字符串
24.      * @param key  加密使用的SecretKey
25.      * @param iv   加密使用的初始化向量（IvParameterSpec）
26.      * @return 加密后的字符串，以Base64编码
27.      * @throws Exception 如果加密过程中发生错误，抛出异常
28.      */
29.     public static String encryptAES(String data, SecretKey key, IvParameterSpec iv) throws Exception {
30.         // 创建Cipher实例，指定使用AES/CBC/PKCS5Padding算法
31.         Cipher cipher = Cipher.getInstance(ALGORITHM);
32.         // 初始化Cipher为加密模式，传入密钥和初始化向量
33.         cipher.init(Cipher.ENCRYPT_MODE, key, iv);
34.         // 将待加密数据转换为字节数组，并执行加密操作
35.         byte[] encryptedData = cipher.doFinal(data.getBytes());
36.         // 将加密后的数据使用Base64编码，并返回
37.         return Base64.getEncoder().encodeToString(encryptedData);
38.     }
40.     /**
41.      * 使用AES算法解密数据
42.      *
43.      * @param encryptedData 待解密的字符串，以Base64编码
44.      * @param key           解密使用的SecretKey
45.      * @param iv            解密使用的初始化向量（IvParameterSpec）
46.      * @return 解密后的字符串
47.      * @throws Exception 如果解密过程中发生错误，抛出异常
48.      */
49.     public static String decryptAES(String encryptedData, SecretKey key, IvParameterSpec iv) throws Exception {
50.         // 创建Cipher实例，指定使用AES/CBC/PKCS5Padding算法
51.         Cipher cipher = Cipher.getInstance(ALGORITHM);
52.         // 初始化Cipher为解密模式，传入密钥和初始化向量
53.         cipher.init(Cipher.DECRYPT_MODE, key, iv);
54.         // 将待解密数据从Base64解码为字节数组
55.         byte[] decodedData = Base64.getDecoder().decode(encryptedData);
56.         // 执行解密操作
57.         byte[] decryptedData = cipher.doFinal(decodedData);
58.         // 将解密后的数据转换为字符串，并返回
59.         return new String(decryptedData);
60.     }
61. }

复制代码

测试代码

1. package com.artisan.shuangxiang_aesrsa;
3. import javax.crypto.SecretKey;
4. import javax.crypto.spec.IvParameterSpec;
5. import java.security.KeyPair;
6. import java.security.PrivateKey;
7. import java.security.PublicKey;
8. import java.util.Base64;
10. /**
11. * @author artisan
12. */
13. public class Main_OnlyAES {
16.     /**
17.      * 使用RSA公钥加密AES密钥，以及使用RSA私钥解密AES密钥的全过程
18.      * 同时展示了使用AES密钥加密和解密数据的应用
19.      *
20.      * @param args 命令行参数
21.      * @throws Exception 可能抛出的异常
22.      */
23.     public static void main(String[] args) throws Exception {
24.         // 生成AES和RSA密钥
25.         SecretKey aesKey = KeyGeneration.generateAESKey();
28.         String aesKeyString = Base64.getEncoder().encodeToString(aesKey.getEncoded());
29.         System.out.println("AES密钥: " + aesKeyString);
30.         // 初始化IV（通常需要确保IV的安全传输）  16字节的IV向量
31.         IvParameterSpec iv = new IvParameterSpec(new byte[16]);
34.         // 使用AES加密和解密数据
35.         String originalData = "我是需要加密的数据artisan GO GO GO !!!";
36.         String encryptedData = AESUtil.encryptAES(originalData, aesKey, iv);
37.         System.out.println("加密的数据: " + encryptedData);
39.         String decryptedData = AESUtil.decryptAES(encryptedData, aesKey, iv);
40.         System.out.println("解密的数据: " + decryptedData);
41.     }
42. }

复制代码

小结

• IV 是加密过程的一部分，用于确保相同的明文在加密时能产生差异的密文，从而进步安全性。
  
• Seed 则是用于初始化随机数天生器，以天生伪随机数，这些伪随机数可以用于天生IV、密钥等。
  

固然IV有时可以通过随机数天生器来天生，这个随机数天生器可能使用Seed作为其输入，但它们的概念和用途是差异的。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。