加密算法实战指南：从哈希、AES到RSA，构建系统安全防线

1. 项目概述：我们为什么需要加密算法？

在数字世界里，数据就是新的石油，而加密算法则是保护这些宝贵资源的“保险库”。无论是你手机里的支付密码、聊天记录，还是企业服务器上的客户资料、商业机密，它们的传输和存储都离不开加密技术的守护。简单来说，加密算法就是一套数学规则，它能把一段可读的“明文”（比如“Hello World”）转换成一堆看起来毫无意义的“密文”（比如“aB3x9!pLm”），只有掌握正确“钥匙”（密钥）的人才能将其还原。这个过程确保了数据的机密性、完整性和真实性，是构建现代数字信任的基石。

作为一名开发者，我几乎每天都会和加密算法打交道。从用户密码的存储（用哈希算法加盐），到API接口的敏感数据传输（用AES或RSA），再到验证文件是否被篡改（计算哈希值），加密无处不在。理解不同加密算法的特性、适用场景和潜在风险，不是一项“加分项”，而是保障系统安全、避免数据泄露事故的“必修课”。这篇文章，我将结合自己十多年的实战经验，为你系统性地拆解那些最常用、最核心的加密算法，不仅告诉你它们是什么，更会深入分析它们“为什么”这么设计，以及在什么情况下该用哪一个，帮你构建起清晰的加密知识体系。

2. 加密算法的三大基石：分类与核心思想

在深入具体算法之前，我们必须先建立一个清晰的分类框架。加密算法主要分为三大类：哈希算法、对称加密算法和非对称加密算法。它们解决的问题不同，设计哲学也截然不同。

2.1 哈希算法：数据的“数字指纹”

哈希算法，也叫散列函数或摘要算法，它的核心特性是单向性和确定性。你可以把它想象成一个高效的“榨汁机”：无论你投入一个苹果还是一车苹果（输入数据），它都能快速输出一杯固定容量的果汁（哈希值）。但你几乎不可能通过这杯果汁还原出原来的苹果。这就是它的单向性。

核心特性解析：

1. 确定性：相同的输入，无论计算多少次，都会产生完全相同的哈希值。
2. 雪崩效应：输入数据的任何微小改动（哪怕只改一个比特），都会导致输出的哈希值发生巨大、不可预测的变化。
3. 抗碰撞性：在计算上，几乎不可能找到两个不同的输入，却产生相同的哈希值。
4. 单向性：从哈希值反推原始输入数据，在计算上是不可行的。

哈希算法主要用于验证数据的完整性（比如下载文件后校验SHA256值是否匹配）和凭证的不可逆存储（比如存储用户密码的哈希值，而非明文）。常见的哈希算法包括MD5、SHA-1、SHA-2家族（SHA-256、SHA-384、SHA-512）以及国密算法SM3。

注意：MD5和SHA-1因其已被证实存在严重的碰撞漏洞，绝对不应用于任何安全敏感的场景，如密码存储或数字签名。它们现在仅用于一些非安全的数据完整性校验，例如校验大文件传输是否完整，但不能用于防篡改。

2.2 对称加密算法：同一把钥匙的保险箱

对称加密，顾名思义，加密和解密使用的是同一把密钥。这就像你和朋友共用一个带锁的盒子（密钥），你把秘密（明文）放进去锁上（加密），寄给朋友，他用同一把钥匙打开（解密）。整个过程高效快捷。

核心特性解析：

1. 高效快速：算法设计相对简单，加解密速度非常快，适合处理大量数据。
2. 密钥管理是核心挑战：通信双方必须安全地共享同一把密钥。如果密钥在传输中被截获，整个加密体系就崩溃了。这就是著名的“密钥分发问题”。
3. 分组与流式：对称加密又分为分组加密（如AES、DES）和流加密。分组加密将数据切成固定大小的块（如128位）逐个处理；流加密则像流水一样，将密钥流与数据流逐位进行运算。

常见的对称加密算法有DES（已淘汰）、3DES（过渡方案）和目前的主流——AES（高级加密标准）。AES根据密钥长度分为AES-128、AES-192和AES-256，密钥越长，安全性越高，但计算开销也略大。

2.3 非对称加密算法：公钥与私钥的完美配合

非对称加密，也称为公钥加密，它使用一对数学上相关联的密钥：公钥和私钥。公钥可以公开给任何人，私钥则必须严格保密。用公钥加密的数据，只能用对应的私钥解密；用私钥签名的数据，任何人都可以用对应的公钥验证签名者身份。

核心思想与优势：

1. 解决密钥分发难题：你只需要公开你的公钥。任何人想给你发加密消息，就用你的公钥加密，而只有你（持有私钥）能解密。无需事先秘密共享密钥。
2. 实现数字签名：你可以用私钥对一段数据（或其哈希值）进行签名，生成一个“签名”。其他人用你的公钥验证这个签名，如果通过，就能证明这段数据确实是你发出的，且未被篡改。这解决了身份认证和不可否认性问题。
3. 计算开销大：非对称加密的数学运算非常复杂，其速度比对称加密慢几个数量级。因此，它不适合直接加密大量数据。

最常见的非对称加密算法是RSA（基于大数分解难题）和ECC（椭圆曲线加密，在相同安全强度下密钥更短，效率更高）。国密算法中的SM2也属于非对称加密。

一个经典的混合加密模式（HTTPS/TLS的核心）： 在实际应用中，我们常将对称和非对称加密结合使用，取长补短：

1. 客户端生成一个随机的对称密钥（称为“会话密钥”）。
2. 客户端用服务器的公钥加密这个会话密钥，并发送给服务器。
3. 服务器用自己的私钥解密，得到会话密钥。
4. 此后，双方使用这个会话密钥和高效的对称加密算法（如AES）进行后续所有通信。

这样，既利用了非对称加密解决密钥安全分发的难题，又享受了对称加密处理大数据量的高效。

3. 哈希算法深度解析：从MD5到国密SM3

哈希算法是开发中最常接触的加密工具之一。我们来深入看看几个代表性算法的演进和实战要点。

3.1 MD5与SHA-1：为何被时代抛弃？

MD5（128位输出）和SHA-1（160位输出）都曾风光无限。MD5因其计算速度快，一度被广泛用于文件校验和密码存储。然而，密码学的发展无情地揭示了它们的脆弱性。

致命弱点：碰撞攻击碰撞攻击是指找到两个不同的输入，产生相同的哈希值。2004年，王小云教授团队公开了MD5的碰撞攻击方法，在普通计算机上几小时内就能找到一对碰撞。这意味着，攻击者可以伪造一个和原文件哈希值相同的恶意文件，而校验程序无法察觉。对于密码存储，虽然从哈希反推密码依然困难，但“彩虹表”攻击（预计算海量密码的哈希值）使得破解简单密码的哈希变得容易。

实战教训：我早期参与的一个老系统就使用了MD5存储密码，且未加盐。在一次安全审计中，我们利用彩虹表轻松“破解”了超过30%的弱密码用户。迁移方案是：当用户下次登录时，用更安全的算法（如bcrypt）重新计算并存储其密码哈希，逐步淘汰旧数据。

3.2 SHA-2家族：当今的中流砥柱

SHA-2是一系列算法的统称，包括SHA-224、SHA-256、SHA-384、SHA-512等，数字代表其输出的哈希值长度（位）。目前，SHA-256是事实上的行业标准。

SHA-256的优势：

• 足够的输出长度：256位（32字节）的输出，使得暴力碰撞的难度呈指数级增长。
• 强大的抗碰撞性：截至目前，没有公开可行的对SHA-256的碰撞攻击方法。
• 广泛的硬件和软件支持：几乎所有编程语言和平台都原生支持SHA-256，甚至有些CPU提供了指令集加速。

Java中使用SHA-256的示例：

import java.security.MessageDigest; import java.util.HexFormat; public class SHA256Demo { public static String calculateSHA256(String input) throws Exception { MessageDigest digest = MessageDigest.getInstance("SHA-256"); byte[] hashBytes = digest.digest(input.getBytes("UTF-8")); // 将字节数组转换为十六进制字符串 return HexFormat.of().formatHex(hashBytes); } public static void main(String[] args) throws Exception { String data = "常用的加密算法分析"; String hash = calculateSHA256(data); System.out.println("原文: " + data); System.out.println("SHA-256哈希值: " + hash); // 输出示例：原文: 常用的加密算法分析 // SHA-256哈希值: 7f83b1657ff1fc53b92dc18148a1d65dfc2d4b1fa3d677284addd200126d9069 } }

一个重要概念：加盐（Salting）即使使用SHA-256，直接哈希密码也是不安全的。如果两个用户密码相同，他们的哈希值也会相同。攻击者破解一个，就等于破解了所有。盐（Salt）是一个随机生成的字符串，在计算哈希前，将其与密码拼接。每个用户的盐都是独一无二且随密码哈希一起存储的。

// 伪代码：密码存储流程 String password = "userInputPassword"; String salt = generateRandomSalt(); // 生成一个长随机字符串 String saltedHash = sha256(salt + password); // 将 salt 和 saltedHash 一起存入数据库 // 验证密码时 String storedSalt = getSaltFromDB(userId); String storedHash = getHashFromDB(userId); String inputHash = sha256(storedSalt + userInputPassword); boolean isCorrect = inputHash.equals(storedHash);

加盐使得针对单个用户的彩虹表攻击失效，因为攻击者必须为每个用户的盐重新计算彩虹表，成本极高。

3.3 密码哈希专用算法：bcrypt, scrypt, Argon2

对于密码存储这个特定场景，有更专业的算法：密钥派生函数（KDF）。它们被设计得故意很慢（消耗大量计算资源和/或内存），以抵御暴力破解。

• bcrypt：基于Blowfish密码，内置盐，并且有一个“成本因子”（work factor）参数可以调整。随着硬件进步，你可以调高成本因子来增加计算时间，从而保持安全性。它是前些年非常流行的选择。
• scrypt：不仅计算慢，还消耗大量内存，使得用定制硬件（如ASIC、FPGA）进行并行暴力破解的成本变得极高。
• Argon2：2015年密码哈希竞赛的获胜者，被认为是当前最先进的密码哈希算法。它提供了对时间、内存和并行计算线程的精细控制。

在Spring Security中使用bcrypt：

import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder; public class PasswordService { private BCryptPasswordEncoder encoder = new BCryptPasswordEncoder(12); // 成本因子设为12 public String encodePassword(String rawPassword) { return encoder.encode(rawPassword); // 自动生成并包含盐 } public boolean matches(String rawPassword, String encodedPassword) { return encoder.matches(rawPassword, encodedPassword); // 自动处理盐和验证 } }

3.4 国密哈希算法：SM3

SM3是我国国家密码管理局发布的商用密码哈希算法，输出长度256位，安全性与SHA-256相当。其设计结构类似于SHA-256，但在压缩函数等细节上有所不同。在国内的金融、政务等涉及国密要求的系统中，SM3是必须使用的算法。

SM3的特点：

• 符合国家标准：满足国内信息系统密码应用要求。
• 效率与安全性平衡：在通用软件平台上的实现效率与SHA-256相近。
• 生态支持：现在主流的密码库（如Bouncy Castle）和许多国产密码设备都已支持SM3。

选择建议：在无特殊合规要求的国际项目中，优先使用SHA-256或Argon2（用于密码）。在国内有国密合规要求的项目中，必须使用SM3。

4. 对称加密算法实战：AES的深入与模式选择

AES（Advanced Encryption Standard）是目前全球最广泛使用的对称加密算法。它取代了老旧的DES和3DES。理解AES，不仅要懂算法，更要懂其工作模式和填充方案。

4.1 AES基础：密钥长度与分组大小

AES的分组大小固定为128位（16字节）。密钥长度有三种：128位、192位、256位。密钥越长，安全性越高，但加解密速度会略有下降。对于绝大多数应用，AES-128已足够安全；处理绝密信息时，可考虑AES-256。

4.2 关键概念：工作模式与初始化向量

原始的AES算法只能加密一个128位的块。为了加密任意长度的数据，我们需要定义如何重复应用AES，这就是工作模式。同时，为了确保即使加密相同明文、使用相同密钥，也能产生不同的密文（防止模式分析攻击），我们需要初始化向量。

常见工作模式对比：

重要提示：绝对不要使用ECB模式！因为它会泄露明文的数据模式。一个经典的例子是，用ECB模式加密一张BMP格式的图片，虽然颜色变了，但图像轮廓依然可见。

4.3 填充方案

对于CBC等需要块加密的模式，如果数据长度不是16字节的整数倍，就需要填充。常见填充有PKCS#5/PKCS#7（最常用）、ISO 10126等。而GCM是流加密模式，不需要填充。

4.4 Java实现AES-GCM完整示例

AES-GCM是目前兼顾安全性、性能和功能（认证）的最佳选择。下面是一个完整的、包含异常处理的Java实现示例：

import javax.crypto.Cipher; import javax.crypto.SecretKey; import javax.crypto.spec.GCMParameterSpec; import javax.crypto.spec.SecretKeySpec; import java.nio.charset.StandardCharsets; import java.security.SecureRandom; import java.util.Base64; public class AesGcmExample { private static final String ALGORITHM = "AES"; private static final String TRANSFORMATION = "AES/GCM/NoPadding"; private static final int TAG_LENGTH_BIT = 128; // GCM认证标签长度，128位是标准且安全的 private static final int IV_LENGTH_BYTE = 12; // GCM推荐IV长度为12字节 /** * 加密 * @param plaintext 明文 * @param key 密钥（必须是16、24或32字节，对应AES-128/192/256） * @return Base64编码的字符串，格式为：IV(12字节) + 密文 + 认证标签(16字节) */ public static String encrypt(String plaintext, byte[] key) throws Exception { // 1. 生成随机IV（初始化向量） byte[] iv = new byte[IV_LENGTH_BYTE]; SecureRandom random = new SecureRandom(); random.nextBytes(iv); // 2. 创建SecretKey SecretKey secretKey = new SecretKeySpec(key, ALGORITHM); // 3. 初始化Cipher为加密模式，指定IV和认证标签长度 Cipher cipher = Cipher.getInstance(TRANSFORMATION); GCMParameterSpec parameterSpec = new GCMParameterSpec(TAG_LENGTH_BIT, iv); cipher.init(Cipher.ENCRYPT_MODE, secretKey, parameterSpec); // 4. 执行加密 byte[] plaintextBytes = plaintext.getBytes(StandardCharsets.UTF_8); byte[] ciphertextWithTag = cipher.doFinal(plaintextBytes); // 这里包含了密文和认证标签 // 5. 将IV和（密文+标签）组合在一起，方便传输/存储 byte[] combined = new byte[iv.length + ciphertextWithTag.length]; System.arraycopy(iv, 0, combined, 0, iv.length); System.arraycopy(ciphertextWithTag, 0, combined, iv.length, ciphertextWithTag.length); // 6. 返回Base64编码 return Base64.getEncoder().encodeToString(combined); } /** * 解密 * @param encryptedBase64 encrypt方法返回的Base64字符串 * @param key 密钥 * @return 解密后的明文 */ public static String decrypt(String encryptedBase64, byte[] key) throws Exception { // 1. 解码Base64 byte[] combined = Base64.getDecoder().decode(encryptedBase64); // 2. 分离IV和（密文+标签） if (combined.length < IV_LENGTH_BYTE) { throw new IllegalArgumentException("加密数据格式错误或已损坏"); } byte[] iv = new byte[IV_LENGTH_BYTE]; byte[] ciphertextWithTag = new byte[combined.length - IV_LENGTH_BYTE]; System.arraycopy(combined, 0, iv, 0, iv.length); System.arraycopy(combined, iv.length, ciphertextWithTag, 0, ciphertextWithTag.length); // 3. 创建SecretKey SecretKey secretKey = new SecretKeySpec(key, ALGORITHM); // 4. 初始化Cipher为解密模式 Cipher cipher = Cipher.getInstance(TRANSFORMATION); GCMParameterSpec parameterSpec = new GCMParameterSpec(TAG_LENGTH_BIT, iv); cipher.init(Cipher.DECRYPT_MODE, secretKey, parameterSpec); // 5. 执行解密（同时验证认证标签） byte[] plaintextBytes = cipher.doFinal(ciphertextWithTag); // 如果标签验证失败，会抛出AEADBadTagException return new String(plaintextBytes, StandardCharsets.UTF_8); } public static void main(String[] args) throws Exception { // 密钥必须是16, 24, 32字节。这里使用AES-128 (16字节) // 警告：在实际项目中，密钥必须安全生成和存储，绝不能硬编码！ String keyString = "0123456789abcdef"; // 16个字符，128位 byte[] key = keyString.getBytes(StandardCharsets.UTF_8); String originalText = "这是一段需要加密的敏感数据，比如API密钥或用户信息。"; System.out.println("原文: " + originalText); String encrypted = encrypt(originalText, key); System.out.println("加密后 (Base64): " + encrypted); String decrypted = decrypt(encrypted, key); System.out.println("解密后: " + decrypted); System.out.println("解密是否成功: " + originalText.equals(decrypted)); } }

代码关键点解析：

1. IV的随机性与唯一性：每次加密都必须使用一个密码学安全的随机IV，且同一密钥下IV不应重复。GCM模式推荐使用12字节的IV。
2. 认证标签：cipher.doFinal()在GCM模式下返回的数据包含了密文和附加的认证标签。解密时，doFinal方法会自动验证标签。如果密文在传输中被篡改，或IV/密钥错误，验证会失败并抛出AEADBadTagException。这提供了完整性和真实性保障。
3. 密钥管理：示例中硬编码密钥是极其危险的做法。在实际系统中，密钥应来自安全的密钥管理系统（KMS）、环境变量或经过加密的配置文件。
4. NoPadding：GCM是流加密模式，不需要填充，所以指定为AES/GCM/NoPadding。

4.5 国密对称算法：SM4

SM4是我国定义的商用分组密码算法，分组长度和密钥长度均为128位。其设计结构与AES不同，采用了非均衡的Feistel结构。性能上与AES-128处于同一量级。在国内有合规要求的项目中，需要使用SM4替代AES。主流密码库（如BouncyCastle的“BC”提供者）都支持SM4算法，其使用方式（模式、填充等）与AES类似。

5. 非对称加密算法核心：RSA与ECC的应用艺术

非对称加密解决了密钥分发问题，但其性能瓶颈决定了它通常不用于直接加密大量数据。

5.1 RSA算法原理与密钥生成

RSA的安全性基于大整数分解的困难性。简单来说：找两个大质数p和q很容易，但把它们的乘积n分解回p和q却极其困难。

1. 密钥生成：
   • 选择两个大质数p和q。
   • 计算n = p * q。n的长度就是密钥长度（如2048位）。
   • 计算欧拉函数φ(n) = (p-1)*(q-1)。
   • 选择一个整数e，满足1 < e < φ(n)，且e与φ(n)互质。通常e=65537。
   • 计算d，使得(d * e) % φ(n) = 1。d就是私钥的一部分。
   • 公钥是(n, e)，私钥是(n, d)。
2. 加密：密文c = m^e mod n（m是明文，需要先转换为小于n的整数）。
3. 解密：明文m = c^d mod n。

Java生成RSA密钥对：

import java.security.KeyPair; import java.security.KeyPairGenerator; import java.security.NoSuchAlgorithmException; public class RSAKeyGen { public static KeyPair generateKeyPair(int keySize) throws NoSuchAlgorithmException { KeyPairGenerator keyGen = KeyPairGenerator.getInstance("RSA"); keyGen.initialize(keySize); // 关键：密钥长度。2048是当前最低要求，3072或4096更安全。 return keyGen.generateKeyPair(); } }

5.2 RSA的典型应用场景

1. 密钥协商：如前文所述，用于加密传输对称加密的会话密钥。
2. 数字签名：
   • 签名：发送方用私钥对数据的哈希值进行加密（签名）。
   • 验签：接收方用发送方的公钥解密签名，得到哈希值H1；同时自己计算收到数据的哈希值H2。如果H1等于H2，则证明数据来自发送方且未被篡改。
3. 小数据加密：直接加密非常小的数据（如一个对称密钥）。因为RSA有长度限制，加密数据长度必须小于密钥长度（例如2048位密钥，最多加密245字节左右的数据）。

5.3 RSA的性能陷阱与填充方案

性能：RSA运算非常慢。加密/解密一个2048位的块，比AES加密/解密同等数据慢上千倍。填充：绝对不能使用“无填充”（NoPadding）的RSA。这会导致严重的脆弱性。必须使用OAEP（最优非对称加密填充）或PKCS#1 v1.5填充。在Java中，应使用"RSA/ECB/OAEPWithSHA-256AndMGF1Padding"这样的完整算法字符串。

Java RSA加密解密示例（使用OAEP填充）：

import javax.crypto.Cipher; import java.security.*; import java.util.Base64; public class RSAOAEPExample { public static void main(String[] args) throws Exception { // 1. 生成密钥对 KeyPairGenerator keyGen = KeyPairGenerator.getInstance("RSA"); keyGen.initialize(2048); KeyPair keyPair = keyGen.generateKeyPair(); PublicKey publicKey = keyPair.getPublic(); PrivateKey privateKey = keyPair.getPrivate(); String originalText = "这是一个用于RSA加密的短消息，比如一个AES密钥。"; // 2. 加密 (使用公钥) Cipher encryptCipher = Cipher.getInstance("RSA/ECB/OAEPWithSHA-256AndMGF1Padding"); encryptCipher.init(Cipher.ENCRYPT_MODE, publicKey); byte[] encryptedBytes = encryptCipher.doFinal(originalText.getBytes("UTF-8")); String encryptedB64 = Base64.getEncoder().encodeToString(encryptedBytes); System.out.println("加密后: " + encryptedB64); // 3. 解密 (使用私钥) Cipher decryptCipher = Cipher.getInstance("RSA/ECB/OAEPWithSHA-256AndMGF1Padding"); decryptCipher.init(Cipher.DECRYPT_MODE, privateKey); byte[] decryptedBytes = decryptCipher.doFinal(Base64.getDecoder().decode(encryptedB64)); String decryptedText = new String(decryptedBytes, "UTF-8"); System.out.println("解密后: " + decryptedText); } }

5.4 椭圆曲线加密与国密SM2

ECC（椭圆曲线加密）是另一种非对称加密算法。与RSA相比，在达到相同安全级别时，ECC所需的密钥长度要短得多。例如，256位的ECC密钥安全性约等于3072位的RSA密钥。这意味着ECC更快、更省资源，特别适合移动设备和物联网场景。

国密SM2是基于椭圆曲线密码的非对称算法，是国家密码局发布的商用标准。它定义了一套完整的体系，包括数字签名、密钥交换和公钥加密。与RSA相比，SM2在相同安全强度下，密钥更短、运算更快、签名更短。在国内密码合规体系中，SM2用于替代RSA和ECDSA。

选择建议：

• 新开发的国际通用系统，非对称部分可优先考虑ECC（如ECDSA签名，ECDH密钥交换）。
• 国内有合规要求的系统，必须使用SM2。
• 维护现有RSA系统的，确保密钥长度至少为2048位，并使用OAEP填充。

6. 算法选择指南与常见问题排查

面对众多算法，如何选择？以下是我总结的决策流程图和常见问题清单。

6.1 算法选择速查表

6.2 常见问题与实战避坑指南

问题1：我该用多长的密钥？

• 对称加密 (AES)：128位足够应对未来十年以上。256位提供“军事级”安全冗余。
• RSA：2048位是当前最低安全底线，新系统建议使用3072或4096位。1024位已不安全。
• ECC：256位（如P-256曲线）提供与3072位RSA相当的安全强度。

问题2：为什么我加密/解密时收到“BadPaddingException”或“AEADBadTagException”？这是最常见的问题之一。

• 密钥不匹配：加密和解密使用的密钥不是同一对。检查密钥来源和加载过程。
• IV不一致：对于CBC、GCM等模式，解密时必须使用加密时生成的同一个IV。你需要将IV和密文一起存储/传输。
• 填充错误：加密时使用了某种填充（如PKCS7），解密时却指定了NoPadding，或者数据在传输中被损坏。
• 算法/模式/填充字符串不匹配：加密时用的是AES/CBC/PKCS5Padding，解密时却用了AES/GCM/NoPadding。必须完全一致。
• 数据被篡改（针对GCM）：如果密文或认证标签在传输中被修改，GCM解密时会抛出AEADBadTagException，这是正常的安全特性。

问题3：如何安全地管理密钥？硬编码在代码里是最大的禁忌！

1. 环境变量：适用于简单应用，将密钥Base64编码后放在环境变量中。
2. 专用配置文件：配置文件本身需加密，或严格设置文件权限。
3. 密钥管理服务：对于生产环境，必须使用KMS（如AWS KMS, Azure Key Vault, 华为云KMS，或开源的HashiCorp Vault）。KMS能提供密钥的生成、轮换、审计和访问控制。

问题4：加密后的数据如何存储？二进制还是文本？加密输出是二进制字节数组。为了便于在JSON、数据库文本字段或URL中传输，通常需要编码为文本格式。

• Base64：最常用，编码后体积膨胀约33%。
• Hex（十六进制）：编码后体积膨胀100%，但人类可读性稍好。
• 存储时：将IV（如果需要）、密文、认证标签（如果是GCM）按约定顺序拼接成一个字节数组，然后对整个数组进行Base64编码。如上面AES-GCM示例所示。

问题5：国密算法（SM2/SM3/SM4）在国际上通用吗？目前，国密算法主要在国内的金融、政务、关键信息基础设施等领域有强制或推荐使用要求。在国际合作或面向全球用户的产品中，通常仍使用国际通用算法（AES, SHA-2, RSA/ECC）。许多开源库（如Bouncy Castle）同时支持国际和国密算法，便于开发跨区域的应用。

最后，记住加密安全的第一原则：不要自己发明加密算法。使用经过时间检验、被全球密码学界广泛审查的标准算法和库（如Java的JCE，Python的cryptography），并严格按照最佳实践来使用它们。加密系统的弱点往往不在于算法本身，而在于脆弱的密钥管理、不当的实现方式或错误的使用模式。