Java加密算法实战：从Base64到国密SM4的原理与实现

1. 项目概述：为什么我们需要了解并亲手实现加密算法？

在Java开发的世界里，无论你是刚入门的新手，还是准备面试的求职者，又或是正在构建一个需要处理敏感数据的成熟系统，“加密”都是一个绕不开的话题。你可能在用户登录时用过MD5，在API通信时接触过RSA，或者在配置文件里见过Base64。但很多时候，我们只是调用一个现成的工具类，对里面到底发生了什么，为什么选择这种算法而不是另一种，以及如何安全地使用它们，可能只有一个模糊的概念。这就像开车只会踩油门和刹车，却不了解发动机和变速箱的工作原理，一旦遇到复杂路况或者车辆报警，就容易束手无策。

最近在和一些开发者交流，包括看一些面试复盘，发现很多朋友对加密算法的理解还停留在“MD5是不可逆的”、“RSA是非对称的”这种概念层面。当被问到“为什么现在不推荐直接用MD5存密码？”、“AES的CBC模式和GCM模式有什么区别？”、“如何生成一个安全的RSA密钥对？”时，往往回答得不够深入。这正是我想写这篇内容的原因——不止于调用API，更要理解其核心，并能用Java清晰、安全地实现出来。

本文将聚焦于五种在Java开发中最常见、最具代表性的加密算法：Base64、MD5、AES、RSA和国密SM4。我不会仅仅给你一堆代码，而是会带你拆解每种算法的设计思路、适用场景、安全要点，并附上可运行、可理解的Java实现代码。无论你是为了巩固基础、应对面试，还是为了在实际项目中做出更合理的技术选型，这篇文章都能提供直接的参考。让我们从最基础的编码算法开始，逐步深入到复杂的密码学世界。

2. 五种核心加密算法深度解析与Java实现

加密技术种类繁多，但根据其目的和原理，我们可以将其分为几大类：编码算法、散列函数（哈希）、对称加密和非对称加密。下面我们将逐一深入。

2.1 Base64：数据编码的“通用翻译官”

首先需要明确，Base64不是加密算法，而是一种编码方式。它的核心目的是解决“如何在不同系统间安全可靠地传输二进制数据”的问题。比如，电子邮件协议最初设计只支持ASCII字符，如果你想发送一张图片（二进制数据），直接传输可能会因为某些控制字符（如换行符）而被邮件服务器篡改。Base64的作用就是将3个字节（24位）的二进制数据，转换为4个ASCII字符，确保数据在传输过程中“完好无损”。

核心原理与Java实现：Base64的编码表由64个字符组成：A-Z、a-z、0-9、+、/，以及用作填充的=。编码过程可以简单理解为“每6位二进制数映射为一个编码字符”。Java标准库从Java 8开始，在java.util.Base64类中提供了强大且易用的支持。

import java.util.Base64; public class Base64Demo { public static void main(String[] args) { String originalInput = "Hello, Java加密世界！"; // 1. 基本编码解码 Base64.Encoder basicEncoder = Base64.getEncoder(); Base64.Decoder basicDecoder = Base64.getDecoder(); String encodedString = basicEncoder.encodeToString(originalInput.getBytes()); System.out.println("Base64编码后: " + encodedString); String decodedString = new String(basicDecoder.decode(encodedString)); System.out.println("Base64解码后: " + decodedString); // 2. URL安全编码（将+和/替换为-和_，避免在URL中产生歧义） Base64.Encoder urlEncoder = Base64.getUrlEncoder(); String urlSafeEncoded = urlEncoder.encodeToString(originalInput.getBytes()); System.out.println("URL安全编码后: " + urlSafeEncoded); // 3. MIME编码（每76个字符插入一个CRLF换行，符合电子邮件标准） Base64.Encoder mimeEncoder = Base64.getMimeEncoder(); String mimeEncoded = mimeEncoder.encodeToString(originalInput.getBytes()); System.out.println("MIME编码后（有换行）: \n" + mimeEncoded); } }

实操心得与注意事项：

• 不是加密！反复强调，Base64编码是公开的、可逆的，任何人都可以轻松解码，绝对不能用它来隐藏敏感信息。它的用途是传输兼容，而非保密。
• 体积膨胀：编码后数据大小会增加约33%（因为每3字节变成4字节）。在传输大量二进制数据（如图片）时需权衡，有时直接使用二进制流更高效。
• Java 8+最佳实践：优先使用java.util.Base64，它线程安全且性能优于老旧的sun.misc.BASE64Encoder等非标准API。
• 填充字符=：当原始数据字节数不是3的倍数时，会在编码结果末尾添加一个或两个=作为填充。某些严格场景下（如JWT），可能需要去掉填充，可以使用Base64.getEncoder().withoutPadding()。

2.2 MD5：消息摘要的“指纹采集器”

MD5（Message-Digest Algorithm 5）是一种广泛使用的密码散列函数，可以产生一个128位（16字节）的散列值，通常呈现为一个32位的十六进制数字字符串。它的设计初衷是确保信息传输的完整性——即数据是否被篡改。就像人的指纹，理论上每个不同的数据输入都会产生一个独一无二的“数字指纹”。

核心原理与Java实现：MD5属于“哈希函数”或“散列算法”，其核心特性是：

1. 单向性：从散列值无法反推出原始数据。
2. 抗碰撞性：极难找到两个不同的数据产生相同的散列值。
3. 雪崩效应：原始数据微小的改动，会导致产生的散列值面目全非。

import java.math.BigInteger; import java.security.MessageDigest; import java.security.NoSuchAlgorithmException; public class MD5Demo { public static String getMD5(String input) { try { // 获取MD5摘要计算器实例 MessageDigest md = MessageDigest.getInstance("MD5"); // 计算摘要，返回字节数组 byte[] messageDigest = md.digest(input.getBytes()); // 将字节数组转换为16进制字符串 BigInteger no = new BigInteger(1, messageDigest); String hashtext = no.toString(16); // 确保32位长度，前面补0 while (hashtext.length() < 32) { hashtext = "0" + hashtext; } return hashtext; } catch (NoSuchAlgorithmException e) { throw new RuntimeException(e); } } public static void main(String[] args) { String data1 = "Hello World"; String data2 = "Hello World!"; System.out.println("MD5 of \"" + data1 + "\": " + getMD5(data1)); System.out.println("MD5 of \"" + data2 + "\": " + getMD5(data2)); // 输出将完全不同，展示雪崩效应 } }

重要警告与演进：尽管MD5曾广泛应用，但它现在已被证实是不安全的，尤其是对于密码存储和数字签名。

• 碰撞攻击：研究人员已经能够高效地制造出具有相同MD5值的不同文件。这意味着攻击者可以伪造一个和原文件MD5一致但内容不同的恶意文件，从而破坏完整性校验。
• 密码存储的误区：过去常用MD5(密码)的方式存储用户密码，这是极其危险的。因为MD5计算速度快，且存在庞大的“彩虹表”（预先计算好的常见密码哈希对照表），可以快速反向查询出原始密码。
• 现代替代方案：
  • 校验文件完整性：对于非安全敏感的场景，如校验下载文件是否完整，SHA-256或SHA-3是更安全的选择。
  • 密码存储：必须使用加盐（Salt）的慢哈希函数，如PBKDF2、BCrypt、SCrypt或Argon2。Java中可以使用PBEKeySpec和SecretKeyFactory来实现PBKDF2。

// 密码存储的正确姿势示例：使用PBKDF2WithHmacSHA256 import javax.crypto.SecretKeyFactory; import javax.crypto.spec.PBEKeySpec; import java.security.SecureRandom; import java.util.Base64; public class PasswordStorageDemo { public static String generateStoredPassword(String password) throws Exception { SecureRandom random = new SecureRandom(); byte[] salt = new byte[16]; // 生成一个随机的盐 random.nextBytes(salt); int iterations = 10000; // 迭代次数，增加计算成本 int keyLength = 256; // 密钥长度 PBEKeySpec spec = new PBEKeySpec(password.toCharArray(), salt, iterations, keyLength); SecretKeyFactory skf = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA256"); byte[] hash = skf.generateSecret(spec).getEncoded(); // 存储时，需要同时保存盐、迭代次数和哈希值 return iterations + ":" + Base64.getEncoder().encodeToString(salt) + ":" + Base64.getEncoder().encodeToString(hash); } public static boolean verifyPassword(String inputPassword, String storedPassword) throws Exception { String[] parts = storedPassword.split(":"); int iterations = Integer.parseInt(parts[0]); byte[] salt = Base64.getDecoder().decode(parts[1]); byte[] storedHash = Base64.getDecoder().decode(parts[2]); PBEKeySpec spec = new PBEKeySpec(inputPassword.toCharArray(), salt, iterations, storedHash.length * 8); SecretKeyFactory skf = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA256"); byte[] inputHash = skf.generateSecret(spec).getEncoded(); // 使用常数时间比较，避免时序攻击 return MessageDigest.isEqual(inputHash, storedHash); } }

2.3 AES：对称加密的“黄金标准”

AES（Advanced Encryption Standard，高级加密标准）是目前最流行、最安全的对称加密算法。对称加密意味着加密和解密使用同一把密钥。它的特点是速度快、效率高，适合加密大量数据，如文件、数据库字段、HTTP请求体等。

核心概念与模式选择：使用AES时，除了密钥，还必须关注工作模式和填充模式。

• 工作模式：定义了如何重复应用算法来加密比一个块更长的消息。
  • ECB（电子密码本）：绝对不要用于加密有意义的数据！相同的明文块会产生相同的密文块，模式泄露严重。
  • CBC（密码块链接）：需要初始化向量（IV），且IV必须随机、唯一，通常和密文一起传输。是传统且常用的模式。
  • GCM（伽罗瓦/计数器模式）：现代推荐模式。它不仅提供保密性，还提供认证（确保数据未被篡改）。它同时是AEAD（认证加密关联数据）算法，效率高，且不需要填充。
• 填充模式：因为AES是块加密（每块16字节），当数据不是16字节的倍数时，需要填充。
  • PKCS5Padding / PKCS7Padding：常用填充方式。
  • NoPadding：无填充，要求数据长度必须是16字节的倍数。

Java实现示例（AES/CBC/PKCS5Padding）：

import javax.crypto.Cipher; import javax.crypto.KeyGenerator; import javax.crypto.SecretKey; import javax.crypto.spec.IvParameterSpec; import java.security.SecureRandom; import java.util.Base64; public class AESCBCDemo { public static void main(String[] args) throws Exception { String plainText = "这是一段需要加密的敏感数据。"; // 1. 生成AES密钥（这里为演示，实际应用中密钥需要安全存储和管理） KeyGenerator keyGen = KeyGenerator.getInstance("AES"); keyGen.init(256); // 指定密钥长度：128, 192, 256 SecretKey secretKey = keyGen.generateKey(); // 2. 生成随机初始化向量IV（对于CBC模式至关重要） byte[] iv = new byte[16]; // AES块大小是16字节 SecureRandom random = new SecureRandom(); random.nextBytes(iv); IvParameterSpec ivSpec = new IvParameterSpec(iv); // 3. 加密 Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding"); cipher.init(Cipher.ENCRYPT_MODE, secretKey, ivSpec); byte[] cipherTextBytes = cipher.doFinal(plainText.getBytes("UTF-8")); String encryptedText = Base64.getEncoder().encodeToString(cipherTextBytes); System.out.println("加密后 (Base64): " + encryptedText); System.out.println("IV (Base64): " + Base64.getEncoder().encodeToString(iv)); // 4. 解密（需要同样的密钥和IV） cipher.init(Cipher.DECRYPT_MODE, secretKey, ivSpec); byte[] decryptedBytes = cipher.doFinal(Base64.getDecoder().decode(encryptedText)); String decryptedText = new String(decryptedBytes, "UTF-8"); System.out.println("解密后: " + decryptedText); } }

Java实现示例（更推荐的AES/GCM/NoPadding）：

import javax.crypto.Cipher; import javax.crypto.KeyGenerator; import javax.crypto.SecretKey; import javax.crypto.spec.GCMParameterSpec; import java.security.SecureRandom; import java.util.Base64; public class AESGCMDemo { public static void main(String[] args) throws Exception { String plainText = "使用GCM模式进行认证加密。"; int GCM_TAG_LENGTH = 128; // 认证标签长度，可以是128, 120, 112, 104, 96位 // 生成密钥 KeyGenerator keyGen = KeyGenerator.getInstance("AES"); keyGen.init(256); SecretKey secretKey = keyGen.generateKey(); // 生成随机Nonce（类似IV，在GCM中通常称为Nonce） byte[] nonce = new byte[12]; // GCM推荐Nonce长度为12字节 SecureRandom random = new SecureRandom(); random.nextBytes(nonce); // 加密 Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding"); GCMParameterSpec spec = new GCMParameterSpec(GCM_TAG_LENGTH, nonce); cipher.init(Cipher.ENCRYPT_MODE, secretKey, spec); // 可以添加关联数据（AAD），这部分数据会被认证但不加密 // cipher.updateAAD("SomeAssociatedData".getBytes()); byte[] cipherTextBytes = cipher.doFinal(plainText.getBytes("UTF-8")); String encryptedText = Base64.getEncoder().encodeToString(cipherTextBytes); System.out.println("GCM加密后: " + encryptedText); System.out.println("Nonce (Base64): " + Base64.getEncoder().encodeToString(nonce)); // 解密 cipher.init(Cipher.DECRYPT_MODE, secretKey, spec); // 如果加密时设置了AAD，解密前也必须设置相同的AAD // cipher.updateAAD("SomeAssociatedData".getBytes()); byte[] decryptedBytes = cipher.doFinal(Base64.getDecoder().decode(encryptedText)); String decryptedText = new String(decryptedBytes, "UTF-8"); System.out.println("GCM解密后: " + decryptedText); } }

实操心得与安全要点：

• 密钥管理是关键：对称加密的安全完全依赖于密钥的保密性。切勿将密钥硬编码在代码中或提交到版本控制系统。应使用专业的密钥管理服务（KMS）、环境变量或在启动时从安全位置注入。
• IV/Nonce必须随机且唯一：对于CBC模式，重复使用相同的IV和密钥是严重的安全漏洞。对于GCM模式，重复使用（Key, Nonce）对会导致完全失去保密性。务必使用密码学安全的随机数生成器（SecureRandom）。
• 优先选择GCM模式：在新的项目中，除非有严格的兼容性要求，否则应优先选择AES-GCM。它提供了机密性、完整性和认证，且通常比“加密+HMAC”的组合方式更高效。
• 注意异常处理：Cipher.doFinal()在解密失败（如密钥错误、密文被篡改、认证失败GCM）时会抛出异常，务必做好异常处理。

2.4 RSA：非对称加密的“信任基石”

RSA是一种非对称加密算法，它使用一对密钥：公钥（Public Key）和私钥（Private Key）。公钥可以公开给任何人，用于加密数据；私钥必须严格保密，用于解密数据。RSA的核心数学原理是大数分解的困难性。它解决了对称加密中“密钥分发”的难题，常用于密钥交换、数字签名和少量数据加密。

核心特点与Java实现：RSA加密的数据长度受密钥长度限制。例如，一个2048位的RSA密钥，能加密的明文最大长度约为245字节（因为需要填充）。因此，RSA通常不直接用于加密大量数据，而是用来加密一个随机的对称密钥（如AES密钥），再用该对称密钥去加密实际数据，这就是典型的“混合加密”系统。

import javax.crypto.Cipher; import java.security.*; import java.util.Base64; public class RSADemo { // 生成RSA密钥对 public static KeyPair generateKeyPair() throws NoSuchAlgorithmException { KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA"); keyPairGen.initialize(2048); // 密钥长度：至少2048位，推荐3072或4096位 return keyPairGen.generateKeyPair(); } // 使用公钥加密 public static String encrypt(String plainText, PublicKey publicKey) throws Exception { Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding"); // 常用填充方案 cipher.init(Cipher.ENCRYPT_MODE, publicKey); byte[] cipherBytes = cipher.doFinal(plainText.getBytes("UTF-8")); return Base64.getEncoder().encodeToString(cipherBytes); } // 使用私钥解密 public static String decrypt(String cipherText, PrivateKey privateKey) throws Exception { Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding"); cipher.init(Cipher.DECRYPT_MODE, privateKey); byte[] plainBytes = cipher.doFinal(Base64.getDecoder().decode(cipherText)); return new String(plainBytes, "UTF-8"); } // 使用私钥签名 public static String sign(String data, PrivateKey privateKey) throws Exception { Signature signature = Signature.getInstance("SHA256withRSA"); signature.initSign(privateKey); signature.update(data.getBytes("UTF-8")); byte[] signBytes = signature.sign(); return Base64.getEncoder().encodeToString(signBytes); } // 使用公钥验签 public static boolean verify(String data, String sign, PublicKey publicKey) throws Exception { Signature signature = Signature.getInstance("SHA256withRSA"); signature.initVerify(publicKey); signature.update(data.getBytes("UTF-8")); return signature.verify(Base64.getDecoder().decode(sign)); } public static void main(String[] args) throws Exception { // 1. 生成密钥对 KeyPair keyPair = generateKeyPair(); PublicKey publicKey = keyPair.getPublic(); PrivateKey privateKey = keyPair.getPrivate(); String originalData = "这是一段用于RSA演示的短数据。"; System.out.println("原文: " + originalData); // 2. 加密解密演示 String encryptedData = encrypt(originalData, publicKey); System.out.println("RSA加密后: " + encryptedData); String decryptedData = decrypt(encryptedData, privateKey); System.out.println("RSA解密后: " + decryptedData); // 3. 签名验签演示 String signature = sign(originalData, privateKey); System.out.println("数字签名: " + signature); boolean isVerified = verify(originalData, signature, publicKey); System.out.println("签名验证结果: " + isVerified); // 尝试篡改数据后验签 boolean isTamperedVerified = verify(originalData + "tampered", signature, publicKey); System.out.println("篡改后签名验证结果: " + isTamperedVerified); // 应为 false } }

实操心得与注意事项：

• 密钥长度：绝对不要使用1024位以下的RSA密钥，它已不安全。当前标准是2048位，对安全性要求高的应用建议使用3072或4096位。
• 加密数据长度限制：如前所述，RSA有明文长度限制。加密时如果数据过长，会抛出IllegalBlockSizeException。务必先检查数据长度，或采用“RSA加密AES密钥，AES加密数据”的混合模式。
• 填充方案的重要性：PKCS1Padding是常用的填充方案，它能增加安全性。不要使用NoPadding，这会导致严重的弱点（如可以对密文进行数学运算来修改明文）。
• 数字签名的本质：签名并非加密，而是用私钥对数据的哈希值进行加密。验证签名时，是用公钥解密签名得到哈希值，再与计算出的数据哈希值对比。这确保了数据的完整性和不可否认性（只有持有私钥的一方才能生成有效签名）。
• 密钥的存储与序列化：生成的Key对象可以调用getEncoded()方法获取其编码格式（通常是PKCS#8 for私钥，X.509 for公钥），然后可以用Base64编码后存储。使用时，需要用KeyFactory来还原。

2.5 SM4：国密算法的“国产主力”

SM4是我国国家密码管理局发布的一种分组对称加密算法，属于国密算法体系。它与AES类似，分组长度和密钥长度均为128位。随着信息安全国产化的推进，在金融、政务等对自主可控要求高的领域，SM4的应用越来越广泛。

核心特点与Java实现：SM4在设计和安全性上与国际通用的AES各有侧重。在Java中，直到JDK 8，标准库并未直接提供SM4的实现。通常需要通过Bouncy Castle（BC）这样的第三方密码学提供者来使用。

使用Bouncy Castle实现SM4（ECB模式示例）：首先，你需要添加Bouncy Castle依赖。以Maven为例：

<dependency> <groupId>org.bouncycastle</groupId> <artifactId>bcprov-jdk15to18</artifactId> <version>1.74</version> <!-- 使用最新版本 --> </dependency>

然后，在代码中注册提供者并实现SM4：

import org.bouncycastle.jce.provider.BouncyCastleProvider; import javax.crypto.Cipher; import javax.crypto.KeyGenerator; import javax.crypto.SecretKey; import javax.crypto.spec.SecretKeySpec; import java.security.Security; import java.util.Base64; public class SM4Demo { static { // 静态代码块中注册Bouncy Castle提供者 Security.addProvider(new BouncyCastleProvider()); } public static void main(String[] args) throws Exception { String plainText = "测试SM4国密算法加密。"; // 1. 生成SM4密钥 KeyGenerator kg = KeyGenerator.getInstance("SM4", "BC"); // 指定算法和提供者 kg.init(128); // SM4密钥长度固定为128位 SecretKey secretKey = kg.generateKey(); byte[] keyBytes = secretKey.getEncoded(); System.out.println("SM4密钥 (Hex): " + bytesToHex(keyBytes)); // 也可以从字节数组加载一个已有的密钥 // SecretKeySpec keySpec = new SecretKeySpec(keyBytes, "SM4"); // 2. 加密 (使用ECB模式，实际生产环境建议使用CBC或GCM等带IV的模式) Cipher cipher = Cipher.getInstance("SM4/ECB/PKCS5Padding", "BC"); cipher.init(Cipher.ENCRYPT_MODE, secretKey); byte[] cipherTextBytes = cipher.doFinal(plainText.getBytes("UTF-8")); String encryptedText = Base64.getEncoder().encodeToString(cipherTextBytes); System.out.println("SM4加密后: " + encryptedText); // 3. 解密 cipher.init(Cipher.DECRYPT_MODE, secretKey); byte[] decryptedBytes = cipher.doFinal(Base64.getDecoder().decode(encryptedText)); String decryptedText = new String(decryptedBytes, "UTF-8"); System.out.println("SM4解密后: " + decryptedText); } // 辅助方法：字节数组转十六进制字符串 private static String bytesToHex(byte[] bytes) { StringBuilder result = new StringBuilder(); for (byte b : bytes) { result.append(String.format("%02x", b)); } return result.toString(); } }

实操心得与注意事项：

• 提供者注册：必须在操作密码相关功能前，将Bouncy Castle注册为安全提供者。通常放在静态代码块中。
• 算法名称：在getInstance方法中，需要明确指定算法为"SM4"，以及提供者为"BC"。
• 模式与填充：和AES一样，SM4也需要选择工作模式和填充模式。示例中使用了不推荐的ECB模式，仅用于演示。在实际应用中，务必使用CBC、CTR或GCM等安全模式，并确保IV的唯一性和随机性。例如：SM4/CBC/PKCS5Padding。
• 密钥管理：同样，对称加密的密钥安全是重中之重。
• 国密生态：除了SM4，国密算法还包括SM2（非对称椭圆曲线加密）、SM3（哈希算法）和SM9（标识密码算法）。在需要完整国密支持的项目中，可能需要使用专门的国密算法库或硬件设备。

3. 算法选型与实战场景指南

了解了每种算法的实现后，如何在项目中做出正确选择？下面是一个快速参考指南。

混合加密实战示例（RSA+AES）：这是现代安全通信（如TLS）的核心理念，结合了非对称加密的密钥分发优势和对称加密的效率优势。

1. 客户端：生成一个随机的AES密钥（会话密钥）。
2. 客户端：使用服务器的RSA公钥加密这个AES会话密钥。
3. 客户端：使用AES会话密钥加密实际要发送的敏感数据。
4. 客户端：将加密后的AES密钥和加密后的数据一起发送给服务器。
5. 服务器：使用自己的RSA私钥解密得到AES会话密钥。
6. 服务器：使用解密得到的AES会话密钥解密数据。

这样，即使通信被监听，攻击者没有服务器的RSA私钥，也无法解密AES会话密钥，从而无法解密任何实际数据。

4. 常见问题排查与Java实战避坑指南

在实际编码和系统集成中，你会遇到各种各样的问题。这里记录了一些典型坑点和解决方案。

4.1 编码与解码相关异常

• 问题：javax.crypto.IllegalBlockSizeException: Input length must be multiple of 16 when decrypting with padded cipher

  • 原因：在使用AES等分组加密解密时，密文字节长度不是块大小（16字节）的整数倍。可能的原因有：密文在传输或存储过程中被截断、损坏；或者加密和解密时使用的算法/模式/填充不匹配。
  • 排查：
    1. 确认加密和解密使用的Cipher.getInstance(“算法/模式/填充”)字符串完全一致。
    2. 检查密文数据是否完整。如果是Base64编码的字符串，确保解码正确，没有丢失字符或混入空格换行。
    3. 如果涉及网络传输，确保没有因为缓冲区大小等问题导致数据不完整。

• 问题：java.security.InvalidKeyException: Illegal key size

  • 原因：Java默认的“受限策略文件”限制了加密密钥的长度。例如，默认可能只允许128位以下的AES密钥。
  • 解决：
    1. （推荐）升级JDK版本：JDK 8u151/8u152及以上版本，以及所有更新的JDK版本，默认已经解除了这个限制。
    2. 对于旧版本JDK，可以手动下载并替换JRE的local_policy.jar和US_export_policy.jar文件（即所谓的“JCE无限强度管辖策略文件”）。

4.2 密钥与参数管理问题

• 问题：相同的明文和密钥，每次加密结果却不同？

  • 原因：这是正常的，而且是安全的体现！如果你使用了CBC、GCM等模式，并且每次使用了随机生成的IV/Nonce，那么加密结果必然不同。IV/Nonce不需要保密，但必须随机且唯一，通常需要和密文一起存储或传输。
  • 注意：如果使用ECB模式，相同的明文密钥会产生相同的密文，这是不安全的。

• 问题：如何安全地存储密钥？

  • 硬编码在代码里：绝对禁止！会随代码泄露。
  • 配置文件：风险较高，如果配置文件泄露则密钥泄露。
  • 环境变量：比配置文件稍好，但仍在服务器上可见。
  • 专用密钥管理服务：推荐方案。如使用云服务商的KMS（密钥管理服务），或部署开源的HashiCorp Vault。应用在运行时动态向KMS请求密钥或执行加解密操作，密钥本身不离开KMS。

4.3 性能与多线程考量

• 问题：Cipher对象线程安全吗？

  • 答案：Cipher对象不是线程安全的。它的内部状态会在init()、update()、doFinal()调用间改变。
  • 最佳实践：不要在多线程间共享同一个Cipher实例。可以为每个线程创建新的实例，或者使用ThreadLocal来缓存。由于Cipher的初始化开销较大，在高并发场景下，使用ThreadLocal是常见的优化手段。

  private static final ThreadLocal<Cipher> AES_CIPHER_THREAD_LOCAL = ThreadLocal.withInitial(() -> { try { return Cipher.getInstance("AES/GCM/NoPadding"); } catch (Exception e) { throw new RuntimeException("Failed to create Cipher", e); } }); public byte[] encryptWithThreadLocal(byte[] data, SecretKey key, byte[] nonce) throws Exception { Cipher cipher = AES_CIPHER_THREAD_LOCAL.get(); GCMParameterSpec spec = new GCMParameterSpec(128, nonce); cipher.init(Cipher.ENCRYPT_MODE, key, spec); return cipher.doFinal(data); }

• 问题：RSA加密解密很慢，影响性能怎么办？

  • 原因：RSA等非对称加密计算复杂度远高于对称加密。
  • 解决：牢记RSA的设计用途——加密少量数据（如一个对称密钥）。永远不要用RSA直接加密大量数据。正确的模式是“混合加密”：用RSA加密一个随机的AES密钥，再用该AES密钥加密实际数据。

4.4 国密算法集成问题

• 问题：java.security.NoSuchAlgorithmException: SM4 KeyGenerator not available
  • 原因：没有正确引入并注册Bouncy Castle提供者。
  • 解决：
    1. 确认项目依赖中已添加Bouncy Castle库。
    2. 确保在代码执行早期（如静态块）调用Security.addProvider(new BouncyCastleProvider())。
    3. 在调用KeyGenerator.getInstance(“SM4”, “BC”)或Cipher.getInstance(“SM4/...”, “BC”)时，显式指定提供者”BC”。

加密算法的选择和实现是构建安全系统的基石。从理解Base64的编码本质，到认清MD5的局限性，再到熟练运用AES和RSA的混合加密模式，最后了解国密SM4的集成，这个过程不仅仅是学习API调用，更是建立一套完整的数据安全思维。在实战中，务必牢记：没有绝对的安全，只有相对于成本和风险的安全。密钥管理比算法本身更重要，持续更新知识以应对新的威胁同样关键。希望这篇结合原理、代码与经验的梳理，能成为你Java安全开发路上的一块扎实的垫脚石。如果在具体的实现中遇到更棘手的问题，多查阅官方文档、密码学标准以及社区的安全实践，总是不会错的。