Java捕获BadPaddingException问题：RSA签名验证异常处理失效

问题场景 #

在实现基于SHA-256+RSA的比特币交易认证系统时，模拟欺诈签名（用错误私钥加密摘要，再用对应公钥解密）会触发BadPaddingException，但在验证函数中添加try/catch捕获该异常时，编译器提示**BadPaddingException在try语句中从未抛出**。

问题根源 #

查看你的RSA类代码，核心问题在于decrypt方法内部直接捕获了所有Exception并处理（打印栈轨迹后返回null），没有将BadPaddingException向上抛出给调用方：

public static byte[] decrypt(byte[] encryptedData, PublicKey keyValue){
    try{
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.DECRYPT_MODE, keyValue);
        return cipher.doFinal(encryptedData);
    } catch(Exception e){
        e.printStackTrace();
        return null;
    }
}

当外部调用decrypt时，所有异常都被方法内部“吃掉”了，编译器自然认为该方法不会抛出任何异常，导致验证函数的catch块报错。

修正方案 #

方案1：让RSA方法抛出具体受检异常 #

修改RSA类的encrypt和decrypt方法，移除内部的try/catch，直接抛出具体的加密相关异常，让调用方处理：

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;

public class RSA {
    // 加密函数：抛出具体异常
    public static byte[] encrypt(byte[] data, PrivateKey keyValue) 
            throws NoSuchAlgorithmException, NoSuchPaddingException, 
                   InvalidKeyException, IllegalBlockSizeException, BadPaddingException {
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.ENCRYPT_MODE, keyValue);
        return cipher.doFinal(data);
    }

    // 解密函数：抛出具体异常
    public static byte[] decrypt(byte[] encryptedData, PublicKey keyValue) 
            throws NoSuchAlgorithmException, NoSuchPaddingException, 
                   InvalidKeyException, IllegalBlockSizeException, BadPaddingException {
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.DECRYPT_MODE, keyValue);
        return cipher.doFinal(encryptedData);
    }
}

然后修改验证函数，针对性捕获异常：

public void VerifyTransaction(Transaction t) {
    NetworkUser sender = t.sender;
    PublicKey senderPK = sender.PublicKeyRSA;
    byte[] transactionDS = t.digitalSignature;
    byte[] contentDigest = functionSHA.hash(t.content);
    
    try {
        // 注意：RSA方法是static的，无需实例化调用
        byte[] DS_decrypted = RSA.decrypt(transactionDS, senderPK); 
        if (MessageDigest.isEqual(contentDigest, DS_decrypted)){
            System.out.println("Transaction approved!");
        } else {
            System.out.println("Invalid signature. Transaction rejected.");
        }
    } catch (BadPaddingException | IllegalBlockSizeException e) {
        // 捕获签名无效导致的填充/块大小异常
        System.out.println("Invalid signature. Transaction rejected.");
    } catch (NoSuchAlgorithmException | NoSuchPaddingException | InvalidKeyException e) {
        // 处理初始化阶段的异常（如密钥无效、算法不存在）
        System.out.println("Verification error: " + e.getMessage());
    }
}

方案2：在RSA方法中抛出RuntimeException（避免受检异常） #

如果不想处理受检异常，可以在decrypt方法中捕获BadPaddingException后，包装成RuntimeException抛出：

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import java.security.PrivateKey;
import java.security.PublicKey;

public class RSA {
    public static byte[] encrypt(byte[] data, PrivateKey keyValue){
        try {
            Cipher cipher = Cipher.getInstance("RSA");
            cipher.init(Cipher.ENCRYPT_MODE, keyValue);
            return cipher.doFinal(data);
        } catch(Exception e){
            e.printStackTrace();
            return null;
        }
    }

    public static byte[] decrypt(byte[] encryptedData, PublicKey keyValue){
        try{
            Cipher cipher = Cipher.getInstance("RSA");
            cipher.init(Cipher.DECRYPT_MODE, keyValue);
            return cipher.doFinal(encryptedData);
        } catch(BadPaddingException e){
            // 将BadPaddingException包装为RuntimeException抛出
            throw new RuntimeException("Invalid signature padding", e);
        } catch(Exception e){
            e.printStackTrace();
            return null;
        }
    }
}

对应的验证函数调整为：

public void VerifyTransaction(Transaction t) {
    NetworkUser sender = t.sender;
    PublicKey senderPK = sender.PublicKeyRSA;
    byte[] transactionDS = t.digitalSignature;
    byte[] contentDigest = functionSHA.hash(t.content);
    
    try {
        byte[] DS_decrypted = RSA.decrypt(transactionDS, senderPK);
        if (DS_decrypted != null && MessageDigest.isEqual(contentDigest, DS_decrypted)){
            System.out.println("Transaction approved!");
        } else {
            System.out.println("Invalid signature. Transaction rejected.");
        }
    } catch (RuntimeException e) {
        if (e.getCause() instanceof BadPaddingException) {
            System.out.println("Invalid signature. Transaction rejected.");
        } else {
            System.out.println("Verification error: " + e.getMessage());
        }
    }
}

额外提示 #

• RSA类中的encrypt和decrypt都是静态方法，无需实例化algorithmRSA对象，直接通过RSA.xxx调用即可（Main类中可以移除static RSA algorithmRSA = new RSA();）。
• 实际数字签名场景中，更规范的做法是使用Signature类（如Signature.getInstance("SHA256withRSA")），它会自动处理摘要+签名的流程，避免手动拼接摘要和加密的错误。

内容的提问来源于stack exchange，提问作者Mirai