Java加密算法库BouncyCastle使用教程

<dependency>
    <groupId>org.bouncycastle</groupId>
    <artifactId>bcprov-jdk18on</artifactId>
    <version>1.78</version> <!-- 请使用最新稳定版本 -->
</dependency>
<dependency>
    <groupId>org.bouncycastle</groupId>
    <artifactId>bcpkix-jdk18on</artifactId>
    <version>1.78</version> <!-- 用于PKIX、CMS、OpenPGP等高级功能 -->
</dependency>

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

public class BouncyCastleInit {
    public static void init() {
        if (Security.getProvider(BouncyCastleProvider.PROVIDER_NAME) == null) {
            Security.addProvider(new BouncyCastleProvider());
            System.out.println("BouncyCastleProvider registered.");
        } else {
            System.out.println("BouncyCastleProvider already registered.");
        }
    }

    public static void main(String[] args) throws Exception {
        init(); // 确保BouncyCastle被注册

        // 举个简单的AES加密解密例子
        // 实际应用中，密钥和IV的生成、存储、传输都需要非常严谨
        String originalText = "Hello, BouncyCastle encryption!";
        byte[] keyBytes = "ThisIsASecretKey".getBytes("UTF-8"); // 16字节AES-128
        byte[] ivBytes = "1234567890123456".getBytes("UTF-8"); // 16字节IV

        // 使用BouncyCastle的AES/CBC/PKCS5Padding
        javax.crypto.Cipher cipher = javax.crypto.Cipher.getInstance("AES/CBC/PKCS5Padding", "BC"); // 指定使用BC提供者
        javax.crypto.spec.SecretKeySpec secretKeySpec = new javax.crypto.spec.SecretKeySpec(keyBytes, "AES");
        javax.crypto.spec.IvParameterSpec ivSpec = new javax.crypto.spec.IvParameterSpec(ivBytes);

        // 加密
        cipher.init(javax.crypto.Cipher.ENCRYPT_MODE, secretKeySpec, ivSpec);
        byte[] encryptedBytes = cipher.doFinal(originalText.getBytes("UTF-8"));
        System.out.println("Encrypted (Base64): " + java.util.Base64.getEncoder().encodeToString(encryptedBytes));

        // 解密
        cipher.init(javax.crypto.Cipher.DECRYPT_MODE, secretKeySpec, ivSpec);
        byte[] decryptedBytes = cipher.doFinal(encryptedBytes);
        String decryptedText = new String(decryptedBytes, "UTF-8");
        System.out.println("Decrypted: " + decryptedText);
    }
}

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

public class HashExample {
    static {
        Security.addProvider(new BouncyCastleProvider());
    }

    public static String calculateSha3_256(String input) throws Exception {
        MessageDigest digest = MessageDigest.getInstance("SHA3-256", "BC"); // 使用BC的SHA3-256
        byte[] hash = digest.digest(input.getBytes("UTF-8"));
        return bytesToHex(hash);
    }

    private static String bytesToHex(byte[] bytes) {
        StringBuilder sb = new StringBuilder();
        for (byte b : bytes) {
            sb.append(String.format("%02x", b));
        }
        return sb.toString();
    }

    public static void main(String[] args) throws Exception {
        String data = "Hello, BouncyCastle Hashing!";
        System.out.println("SHA3-256 Hash: " + calculateSha3_256(data));
    }
}

import java.security.*;
import java.util.Base64;
import org.bouncycastle.jce.provider.BouncyCastleProvider;

public class DigitalSignatureExample {
    static {
        Security.addProvider(new BouncyCastleProvider());
    }

    public static void main(String[] args) throws Exception {
        // 1. 生成密钥对 (ECDSA with P-256 curve)
        KeyPairGenerator keyGen = KeyPairGenerator.getInstance("EC", "BC");
        keyGen.initialize(256, new SecureRandom()); // 256位曲线，如secp256r1
        KeyPair keyPair = keyGen.generateKeyPair();
        PublicKey publicKey = keyPair.getPublic();
        PrivateKey privateKey = keyPair.getPrivate();

        System.out.println("Public Key (Base64): " + Base64.getEncoder().encodeToString(publicKey.getEncoded()));
        System.out.println("Private Key (Base64): " + Base64.getEncoder().encodeToString(privateKey.getEncoded()));

        // 2. 待签名数据
        String dataToSign = "This is the message to be digitally signed.";
        byte[] dataBytes = dataToSign.getBytes("UTF-8");

        // 3. 使用私钥签名
        Signature signature = Signature.getInstance("SHA256withECDSA", "BC");
        signature.initSign(privateKey);
        signature.update(dataBytes);
        byte[] signedData = signature.sign();
        System.out.println("Signed Data (Base64): " + Base64.getEncoder().encodeToString(signedData));

        // 4. 使用公钥验证签名
        Signature verifier = Signature.getInstance("SHA256withECDSA", "BC");
        verifier.initVerify(publicKey);
        verifier.update(dataBytes);
        boolean verified = verifier.verify(signedData);
        System.out.println("Signature Verified: " + verified);

        // 尝试篡改数据，验证会失败
        String tamperedData = "This is the tampered message.";
        verifier.update(tamperedData.getBytes("UTF-8"));
        boolean tamperedVerified = verifier.verify(signedData);
        System.out.println("Tampered Signature Verified: " + tamperedVerified);
    }
}