Java中的密码学API：使用BC（Bouncy Castle）库实现高级加密算法 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

Java中使用Bouncy Castle实现高级加密算法

大家好，今天我们来深入探讨Java的密码学API，并且重点关注如何使用Bouncy Castle（BC）库来实现高级加密算法。Java自带的javax.crypto包提供了基础的加密功能，但BC库作为一个第三方库，提供了更广泛、更先进的加密算法和协议支持，包括一些最新的算法和国密算法等。这使得它在安全性要求较高的应用中非常受欢迎。

1. Java密码学API概述

在深入Bouncy Castle之前，我们先回顾一下Java自带的密码学API，即javax.crypto包。这个包提供了对称加密、非对称加密、消息摘要、密钥管理等核心功能。

Cipher类: 用于加解密数据的核心类。它支持各种对称和非对称加密算法，以及不同的工作模式和填充模式。
KeyGenerator类: 用于生成对称密钥。
KeyPairGenerator类: 用于生成非对称密钥对。
SecretKey和PublicKey/PrivateKey接口: 分别表示对称密钥和非对称密钥。
MessageDigest类: 用于计算消息摘要（哈希值）。
Signature类: 用于数字签名。
KeyStore类: 用于安全地存储密钥和证书。
Mac类: 用于消息认证码 (Message Authentication Code)。

虽然javax.crypto提供了基本功能，但其支持的算法种类有限，并且更新速度相对较慢。这就是Bouncy Castle发挥作用的地方。

2. Bouncy Castle库介绍

Bouncy Castle是一个开源的密码学库，它提供了比Java标准库更广泛的算法支持和更灵活的配置选项。它的主要优点包括：

广泛的算法支持: 包括AES, DES, Blowfish, Twofish, Serpent等对称加密算法；RSA, DSA, ECC等非对称加密算法；SHA系列, RIPEMD系列等哈希算法；以及SM2, SM3, SM4等国密算法。
灵活的配置选项: 允许开发者根据需要选择不同的工作模式、填充模式、密钥大小等。
持续更新: Bouncy Castle团队会定期更新库，以支持新的算法和协议，并修复安全漏洞。
开源免费: 可以免费使用并集成到商业或开源项目中。
轻量级: 库体积相对较小，不会显著增加应用程序的大小。

3. 集成Bouncy Castle库

要使用Bouncy Castle，首先需要将其添加到你的Java项目中。通常，你可以通过Maven或Gradle等构建工具来管理依赖。

Maven:

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

Gradle:

dependencies {
    implementation 'org.bouncycastle:bcprov-jdk18on:1.77' // 使用最新版本
}

请注意，bcprov-jdk18on是Bouncy Castle Provider的JAR包，它包含了主要的加密算法实现。 jdk18on 表示版本兼容，针对Java 18及以上版本进行了优化。您应该根据您的Java版本选择对应的版本。

成功添加依赖后，你需要在代码中注册Bouncy Castle Provider，以便Java Security API能够找到并使用它提供的算法。

import java.security.Security;
import org.bouncycastle.jce.provider.BouncyCastleProvider;

public class BouncyCastleSetup {
    public static void main(String[] args) {
        Security.addProvider(new BouncyCastleProvider());
        System.out.println("Bouncy Castle Provider registered.");
    }
}

这段代码将Bouncy Castle Provider添加到Java Security Providers列表中。确保在任何加密操作之前执行此操作。 Security.getProviders() 方法可以用来查看当前注册的所有 Provider。

4. 使用Bouncy Castle实现AES加密

AES（Advanced Encryption Standard）是一种广泛使用的对称加密算法。下面是如何使用Bouncy Castle实现AES加密和解密的示例：

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.IvParameterSpec;
import java.security.SecureRandom;
import java.security.Security;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import java.util.Base64;

public class AESExample {

    public static void main(String[] args) throws Exception {
        Security.addProvider(new BouncyCastleProvider());

        // 1. 生成AES密钥
        KeyGenerator keyGenerator = KeyGenerator.getInstance("AES", "BC"); // 指定Bouncy Castle Provider
        keyGenerator.init(256, new SecureRandom()); // 初始化密钥生成器，指定密钥长度为256位
        SecretKey secretKey = keyGenerator.generateKey();

        // 2. 创建初始化向量 (IV)
        SecureRandom secureRandom = new SecureRandom();
        byte[] iv = new byte[16]; // AES IV length is 16 bytes
        secureRandom.nextBytes(iv);
        IvParameterSpec ivParameterSpec = new IvParameterSpec(iv);

        // 3. 初始化Cipher对象，选择加密算法、工作模式和填充模式
        Cipher cipher = Cipher.getInstance("AES/CBC/PKCS7Padding", "BC"); // 使用CBC模式和PKCS7填充

        // 4. 加密数据
        cipher.init(Cipher.ENCRYPT_MODE, secretKey, ivParameterSpec);
        String plaintext = "This is a secret message!";
        byte[] ciphertext = cipher.doFinal(plaintext.getBytes());
        String encodedCiphertext = Base64.getEncoder().encodeToString(ciphertext);
        System.out.println("Ciphertext: " + encodedCiphertext);

        // 5. 解密数据
        cipher.init(Cipher.DECRYPT_MODE, secretKey, ivParameterSpec);
        byte[] decryptedText = cipher.doFinal(ciphertext);
        String decodedPlaintext = new String(decryptedText);
        System.out.println("Plaintext: " + decodedPlaintext);
    }
}

代码解释:

注册Provider: Security.addProvider(new BouncyCastleProvider()); 注册Bouncy Castle Provider。
生成密钥: KeyGenerator.getInstance("AES", "BC") 获取AES密钥生成器，并指定使用Bouncy Castle Provider。密钥长度设置为256位。
创建IV: 对于CBC等工作模式，需要使用初始化向量（IV）。IV用于确保即使使用相同的密钥加密相同的明文，也会生成不同的密文。 IvParameterSpec 用于包装IV。
初始化Cipher: Cipher.getInstance("AES/CBC/PKCS7Padding", "BC") 指定使用AES算法、CBC工作模式和PKCS7填充模式。 PKCS7Padding 是一种常用的填充模式，用于确保明文长度是块大小的整数倍。
加密和解密: cipher.init() 方法用于初始化Cipher对象，指定加密或解密模式，以及密钥和IV。 cipher.doFinal() 方法执行实际的加密或解密操作。
Base64编码: 加密后的密文是二进制数据，为了方便传输和存储，通常会使用Base64编码将其转换为字符串。

注意:

密钥长度的选择会影响安全性。通常，256位AES密钥被认为是足够安全的。
选择合适的工作模式和填充模式也很重要。CBC模式需要使用IV，而ECB模式则不需要。PKCS7Padding是一种常用的填充模式，它适用于大多数块加密算法。
在实际应用中，密钥和IV应该安全地存储和管理，避免泄露。

5. 使用Bouncy Castle实现RSA加密

RSA是一种常用的非对称加密算法。下面是如何使用Bouncy Castle实现RSA加密和解密的示例：

import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.Security;
import javax.crypto.Cipher;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import java.util.Base64;

public class RSAExample {

    public static void main(String[] args) throws Exception {
        Security.addProvider(new BouncyCastleProvider());

        // 1. 生成RSA密钥对
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA", "BC");
        keyPairGenerator.initialize(2048); // 密钥长度为2048位
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        PublicKey publicKey = keyPair.getPublic();
        PrivateKey privateKey = keyPair.getPrivate();

        // 2. 使用公钥加密数据
        Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding", "BC"); // 使用PKCS1Padding
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        String plaintext = "This is a secret message!";
        byte[] ciphertext = cipher.doFinal(plaintext.getBytes());
        String encodedCiphertext = Base64.getEncoder().encodeToString(ciphertext);
        System.out.println("Ciphertext: " + encodedCiphertext);

        // 3. 使用私钥解密数据
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        byte[] decryptedText = cipher.doFinal(ciphertext);
        String decodedPlaintext = new String(decryptedText);
        System.out.println("Plaintext: " + decodedPlaintext);
    }
}

代码解释:

生成密钥对: KeyPairGenerator.getInstance("RSA", "BC") 获取RSA密钥对生成器，并指定使用Bouncy Castle Provider。密钥长度设置为2048位。
初始化Cipher: Cipher.getInstance("RSA/ECB/PKCS1Padding", "BC") 指定使用RSA算法和PKCS1Padding填充模式。由于RSA通常用于加密少量数据（例如密钥），因此通常使用ECB模式，但需要注意的是，ECB模式在某些情况下可能不安全。
加密和解密: 使用公钥加密，私钥解密。

注意:

RSA的密钥长度应该足够长，以确保安全性。通常，2048位或更长的密钥被认为是安全的。
RSA算法通常用于加密少量数据，例如对称密钥。不建议使用RSA加密大量数据，因为它效率较低。

6. 使用Bouncy Castle实现SM2加密（国密算法）

SM2是中国国家密码管理局（国家密码局）发布的一种椭圆曲线公钥密码算法。Bouncy Castle提供了对SM2算法的支持。

import org.bouncycastle.asn1.gm.GMNamedCurves;
import org.bouncycastle.asn1.x9.X9ECParameters;
import org.bouncycastle.crypto.engines.SM2Engine;
import org.bouncycastle.crypto.generators.ECKeyPairGenerator;
import org.bouncycastle.crypto.params.ECDomainParameters;
import org.bouncycastle.crypto.params.ECKeyGenerationParameters;
import org.bouncycastle.crypto.params.ECPrivateKeyParameters;
import org.bouncycastle.crypto.params.ECPublicKeyParameters;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.bouncycastle.util.encoders.Hex;

import java.security.SecureRandom;
import java.security.Security;

public class SM2Example {

    public static void main(String[] args) throws Exception {
        Security.addProvider(new BouncyCastleProvider());

        // 1. 获取SM2椭圆曲线参数
        X9ECParameters sm2ECParameters = GMNamedCurves.getByName("sm2p256v1");
        ECDomainParameters domainParams = new ECDomainParameters(sm2ECParameters.getCurve(), sm2ECParameters.getG(), sm2ECParameters.getN());

        // 2. 生成SM2密钥对
        ECKeyPairGenerator keyPairGenerator = new ECKeyPairGenerator();
        ECKeyGenerationParameters keyGenerationParams = new ECKeyGenerationParameters(domainParams, new SecureRandom());
        keyPairGenerator.init(keyGenerationParams);
        org.bouncycastle.crypto.AsymmetricCipherKeyPair keyPair = keyPairGenerator.generateKeyPair();
        ECPrivateKeyParameters privateKey = (ECPrivateKeyParameters) keyPair.getPrivate();
        ECPublicKeyParameters publicKey = (ECPublicKeyParameters) keyPair.getPublic();

        // 3. 使用SM2加密
        SM2Engine engine = new SM2Engine();
        engine.init(true, publicKey); // true for encryption, false for decryption
        byte[] plaintext = "This is a secret message!".getBytes();
        byte[] ciphertext = engine.processBlock(plaintext, 0, plaintext.length);
        String encodedCiphertext = Hex.toHexString(ciphertext);
        System.out.println("Ciphertext: " + encodedCiphertext);

        // 4. 使用SM2解密
        engine.init(false, privateKey); // false for decryption
        byte[] decryptedText = engine.processBlock(ciphertext, 0, ciphertext.length);
        String decodedPlaintext = new String(decryptedText);
        System.out.println("Plaintext: " + decodedPlaintext);
    }
}

代码解释:

获取SM2椭圆曲线参数: GMNamedCurves.getByName("sm2p256v1") 获取SM2椭圆曲线参数。 sm2p256v1 是SM2算法的标准曲线名称。
生成SM2密钥对: 使用 ECKeyPairGenerator 生成椭圆曲线密钥对。
使用SM2加密和解密: SM2Engine 类用于执行SM2加密和解密操作。 init() 方法用于初始化引擎，指定加密或解密模式，以及公钥或私钥。

注意:

SM2算法是中国国家密码管理局推荐使用的密码算法，在一些特定的应用场景中必须使用。
Bouncy Castle提供了对SM2算法的完整支持，包括加密、解密、签名和验签等功能。

7. 使用Bouncy Castle实现SM3哈希算法（国密算法）

SM3是中国国家密码管理局（国家密码局）发布的一种密码哈希函数。Bouncy Castle同样提供了对SM3算法的支持。

import org.bouncycastle.crypto.digests.SM3Digest;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.bouncycastle.util.encoders.Hex;

import java.security.Security;

public class SM3Example {

    public static void main(String[] args) throws Exception {
        Security.addProvider(new BouncyCastleProvider());

        // 1. 创建SM3摘要对象
        SM3Digest digest = new SM3Digest();

        // 2. 更新摘要
        String message = "This is a message to be hashed!";
        byte[] messageBytes = message.getBytes();
        digest.update(messageBytes, 0, messageBytes.length);

        // 3. 计算哈希值
        byte[] hash = new byte[digest.getDigestSize()];
        digest.doFinal(hash, 0);

        // 4. 将哈希值转换为十六进制字符串
        String encodedHash = Hex.toHexString(hash);
        System.out.println("SM3 Hash: " + encodedHash);
    }
}

代码解释:

创建SM3摘要对象: SM3Digest 类用于计算SM3哈希值。
更新摘要: update() 方法用于将要计算哈希值的数据添加到摘要对象中。
计算哈希值: doFinal() 方法用于计算最终的哈希值。

注意:

SM3哈希算法的输出长度为256位。
SM3算法在中国的密码学应用中被广泛使用。

8. 使用Bouncy Castle实现SM4分组密码算法（国密算法）

SM4是中国国家密码管理局（国家密码局）发布的一种分组密码算法。 Bouncy Castle 同样提供了对 SM4 算法的支持。

import org.bouncycastle.crypto.CipherParameters;
import org.bouncycastle.crypto.engines.SM4Engine;
import org.bouncycastle.crypto.modes.CBCBlockCipher;
import org.bouncycastle.crypto.paddings.PKCS7Padding;
import org.bouncycastle.crypto.paddings.PaddedBufferedBlockCipher;
import org.bouncycastle.crypto.params.KeyParameter;
import org.bouncycastle.crypto.params.ParametersWithIV;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.bouncycastle.util.encoders.Hex;

import java.security.SecureRandom;
import java.security.Security;

public class SM4Example {

    public static void main(String[] args) throws Exception {
        Security.addProvider(new BouncyCastleProvider());

        // 1. 生成 SM4 密钥
        SecureRandom secureRandom = new SecureRandom();
        byte[] key = new byte[16]; // SM4 密钥长度为 128 位 (16 字节)
        secureRandom.nextBytes(key);
        KeyParameter keyParameter = new KeyParameter(key);

        // 2. 生成初始化向量 (IV) - 可选，取决于工作模式
        byte[] iv = new byte[16]; // SM4 的块大小为 128 位 (16 字节)
        secureRandom.nextBytes(iv);
        ParametersWithIV ivParameter = new ParametersWithIV(keyParameter, iv);

        // 3. 创建 SM4 引擎 (CBC 模式和 PKCS7 填充)
        PaddedBufferedBlockCipher cipher = new PaddedBufferedBlockCipher(new CBCBlockCipher(new SM4Engine()), new PKCS7Padding());

        // 4. 加密数据
        cipher.init(true, ivParameter); // true 表示加密，false 表示解密
        String plaintext = "This is a secret message!";
        byte[] plaintextBytes = plaintext.getBytes();
        byte[] ciphertextBytes = new byte[cipher.getOutputSize(plaintextBytes.length)];
        int processLen = cipher.processBytes(plaintextBytes, 0, plaintextBytes.length, ciphertextBytes, 0);
        cipher.doFinal(ciphertextBytes, processLen);

        String encodedCiphertext = Hex.toHexString(ciphertextBytes);
        System.out.println("Ciphertext: " + encodedCiphertext);

        // 5. 解密数据
        cipher.init(false, ivParameter); // false 表示解密
        byte[] decryptedBytes = new byte[cipher.getOutputSize(ciphertextBytes.length)];
        processLen = cipher.processBytes(ciphertextBytes, 0, ciphertextBytes.length, decryptedBytes, 0);
        cipher.doFinal(decryptedBytes, processLen);

        String decodedPlaintext = new String(decryptedBytes).trim(); // trim() 移除填充
        System.out.println("Plaintext: " + decodedPlaintext);
    }
}

代码解释:

生成密钥: SecureRandom 用于生成随机的 SM4 密钥，长度为 16 字节 (128 位)。
生成 IV (如果使用 CBC 模式): 如果使用 CBC 模式，需要生成一个随机的初始化向量 (IV)。 IV 的长度与 SM4 的块大小相同，即 16 字节。
创建 SM4 引擎: SM4Engine 是 SM4 算法的核心引擎。 CBCBlockCipher 将 SM4 引擎包装在 CBC (Cipher Block Chaining) 模式中。 PaddedBufferedBlockCipher 提供了填充功能，这里使用 PKCS7Padding。
加密和解密: cipher.init() 用于初始化密码引擎，指定加密或解密模式，以及密钥和 IV。 cipher.processBytes() 用于处理数据块，并将结果写入输出缓冲区。 cipher.doFinal() 用于处理剩余的数据，并进行填充 (如果需要)。解密后通常需要 trim() 函数移除填充。

注意:

SM4 算法的密钥长度为 128 位 (16 字节)。
SM4 算法的块大小为 128 位 (16 字节)。
可以选择不同的工作模式 (例如 ECB, CBC, CTR 等) 和填充模式 (例如 PKCS7, ISO10126 等)。选择合适的工作模式和填充模式对于安全性至关重要。

9. 总结

Bouncy Castle 是一个强大的Java密码学库，它提供了比Java标准库更广泛的算法支持和更灵活的配置选项。通过使用Bouncy Castle，开发者可以轻松地实现各种高级加密算法，包括AES、RSA以及国密算法如SM2、SM3和SM4。在实际应用中，需要根据具体的安全需求选择合适的算法和参数，并安全地管理密钥和IV，以确保数据的安全性。灵活运用BC库，可以更好的应对安全挑战。

Java中使用Bouncy Castle实现高级加密算法

发表回复 取消回复

发表回复取消回复