RSA加密解密示例代码

import javax.crypto.Cipher;
import java.security.*;
import java.util.Base64;
import java.nio.charset.StandardCharsets;
import java.io.ByteArrayOutputStream;

public class RSADemo {

    // 加密时每块的最大字节数，对于1024位RSA密钥，通常为117字节
    private static final int MAX_ENCRYPT_BLOCK = 117;
    // 解密时每块的最大字节数，对于1024位RSA密钥，通常为128字节
    private static final int MAX_DECRYPT_BLOCK = 128;

    public static void main(String[] args) throws Exception {
        // 生成RSA密钥对
        KeyPair keyPair = generateKeyPair();
        PublicKey publicKey = keyPair.getPublic();
        PrivateKey privateKey = keyPair.getPrivate();

        // 原始文本
        String originalText = "Hello, RSA Encryption!";
        // 加密文本
        String encryptedText = encrypt(originalText, publicKey);
        System.out.println("Encrypted Text: " + encryptedText);

        // 解密文本
        String decryptedText = decrypt(encryptedText, privateKey);
        System.out.println("Decrypted Text: " + decryptedText);
    }

    // 生成RSA密钥对的方法
    private static KeyPair generateKeyPair() throws NoSuchAlgorithmException {
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
        keyPairGenerator.initialize(1024);
        return keyPairGenerator.generateKeyPair();
    }

    // 使用公钥加密文本
    private static String encrypt(String plainText, PublicKey publicKey) throws Exception {
        Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        byte[] encryptedData = processData(plainText.getBytes(StandardCharsets.UTF_8), cipher, MAX_ENCRYPT_BLOCK);
        return Base64.getEncoder().encodeToString(encryptedData);
    }

    // 使用私钥解密文本
    private static String decrypt(String encryptedText, PrivateKey privateKey) throws Exception {
        Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        byte[] decryptedData = processData(Base64.getDecoder().decode(encryptedText), cipher, MAX_DECRYPT_BLOCK);
        return new String(decryptedData, StandardCharsets.UTF_8);
    }

    // 处理加密或解密数据的方法
    private static byte[] processData(byte[] data, Cipher cipher, int maxBlockSize) throws Exception {
        int inputLen = data.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        while (inputLen - offSet > 0) {
            // 确定当前块的大小
            if (inputLen - offSet > maxBlockSize) {
                cache = cipher.doFinal(data, offSet, maxBlockSize);
            } else {
                cache = cipher.doFinal(data, offSet, inputLen - offSet);
            }
            // 将加密或解密后的块写入输出流
            out.write(cache, 0, cache.length);
            offSet += maxBlockSize;
        }
        return out.toByteArray();
    }
}

为什么加密的分段大小和解密的分段大小不同：

加密分段大小 (MAX_ENCRYPT_BLOCK): 在RSA加密中，由于使用了填充（如PKCS#1 v1.5），可加密的最大数据量小于密钥长度。对于1024位RSA密钥，有效载荷大小大约是117字节，因为需要留出空间给填充和可能的会话密钥等。

解密分段大小 (MAX_DECRYPT_BLOCK): 解密时，数据块的大小等于密钥长度除以8。对于1024位RSA密钥，这意味着解密块的大小是128字节。这是因为在加密过程中添加的填充在解密时被移除，因此解密块可以容纳整个加密数据块（包括填充）。