RSA解密期间的javax.crypto.BadPaddingException

Question

在我的Java代码中，我试图使用带有公开密钥的RSA加密字符串。 该字符串是表示图像的Base64编码的字符串（图像已转换为字符串）。 它将使用私钥解密。

在加密期间，我首先收到一个异常“ javax.crypto.IllegalBlockSizeException：数据不得超过190个字节”。 因此，我以189的块形式处理了字符串（纯文本），然后对其进行了解析。

在解密期间，我得到了另一个异常“ javax.crypto.IllegalBlockSizeException：数据不得超过256个字节”。 因此，我先将byte []（密文）以256块的形式转换为String，然后再将其解析，从而处理了它。

同样，在解密过程中，我最终遇到了“ javax.crypto.BadPaddingException：解密错误”异常，但我无法解决。

根据该站点专家的建议，我使用了“ OAEPWithSHA-256AndMGF1Padding”。 在其他填充方法之后，我什至尝试使用No Padding，以查看Exception是否会消失，但是它不起作用。 我做错了什么？

我能够确定在行上抛出了异常-解密的图像部分= t.rsaDecrypt（cipherTextTrimmed.getBytes（），privateKey）； -位于main方法的解密部分中。

如果我的编码实践不佳，请多多包涵。 我真的很想现在才找出异常背后的错误。

import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;

public class Tester
{

    public KeyPair buildKeyPair() throws NoSuchAlgorithmException 
    {
        final int keySize = 2048;
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
        keyPairGenerator.initialize(keySize);
        return keyPairGenerator.genKeyPair();   
    }

    public byte[] encrypt(PublicKey publicKey, String message) throws Exception
    {
        Cipher cipher = Cipher.getInstance("RSA/ECB/OAEPWithSHA-256AndMGF1Padding");  
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);  
        return cipher.doFinal(message.getBytes());  
    }

    public String decrypt(PrivateKey privateKey, byte [] encrypted) throws Exception
    { 
        Cipher cipher = Cipher.getInstance("RSA/ECB/OAEPWithSHA-256AndMGF1Padding");  
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        return new String(cipher.doFinal(encrypted));
    }

    public byte[] rsaEncrypt(String watermarkMsg, PublicKey publicKey) throws Exception
    {
        byte[] cipherText = encrypt(publicKey, watermarkMsg);
        return cipherText;
    }

    public String rsaDecrypt(byte[] cipherText, PrivateKey privateKey) throws Exception
    {
        String plainText = decrypt(privateKey, cipherText);
        return plainText;
    }

    public static void main(String args[]) throws NoSuchAlgorithmException
    {
        Tester t = new Tester();

        String inputImageFilePath = "<file_path_here";
        String stringOfImage = null;
        byte[] encryptedImage = null;
        byte[] encryptedImagePartial = null;
        KeyPair keyPair = t.buildKeyPair();
        PublicKey pubKey = keyPair.getPublic();
        PrivateKey privateKey = keyPair.getPrivate()

        //-----------IMAGE TO STRING CONVERSION----------------
        //The imagetostring() function retrieves the image at the file path and converts it into a Base64 encoded String  
        try
        {
            stringOfImage = t.imagetostring(inputImageFilePath);
        }
        catch(Exception e)
        {
            System.out.println(e.toString());
        }

        //-----------ENCRYPTION OF STRING----------------
        //The encryption is done in blocks of 189, because earlier I got an exception - "javax.crypto.IllegalBlockSizeException: Data must not be longer than 190 bytes"
        try
        {
            String plaintext = stringOfImage;
            String plaintextTrimmed = "";
            System.out.println(stringOfImage);
            encryptedImage = new byte[15512];    //The size is given as 15512 because the length of the particular string was found to be 15512
            while(plaintext!="")
            {
                if(plaintext.length()>189)
                {
                    plaintextTrimmed = plaintext.substring(0, 189);
                    plaintext = plaintext.substring(189);
                }
                else
                {
                    plaintextTrimmed = plaintext;
                    plaintext = "";
                }
                encryptedImagePartial = t.rsaEncrypt(plaintextTrimmed, pubKey);
                encryptedImage = t.concatenate(encryptedImage, encryptedImagePartial);
                System.out.println(encryptedImage.length);
            }

        }
        catch(Exception e)
        {
            System.out.println(e.toString());
        }
        t.byteDigest(encryptedImage);

        //-----------DECRYPTION OF STRING--------------
        //The decryption is done in blocks of 189, because earlier I got an exception - "javax.crypto.IllegalBlockSizeException: Data must not be longer than 256 bytes"
        try
        {
            // The ciphertext is located in the variable encryptedImage which is a byte[]
            String stringRepOfCipherText = new String(encryptedImage);              String cipherTextTrimmed = "";
            String decryptedImagePartial;
            String decryptedImage = "";
            while(stringRepOfCipherText!="")
            {
                if(stringRepOfCipherText.length()>189)
                {
                    cipherTextTrimmed = stringRepOfCipherText.substring(0, 189);
                    stringRepOfCipherText = stringRepOfCipherText.substring(189);
                }
                else
                {
                    cipherTextTrimmed = stringRepOfCipherText;
                    stringRepOfCipherText = "";
                }
                decryptedImagePartial = t.rsaDecrypt(cipherTextTrimmed.getBytes(), privateKey);
                decryptedImage = decryptedImage + decryptedImagePartial;
            }
        }
        catch(BadPaddingException e)
        {
            System.out.println(e.toString());
        }
        catch(Exception e)
        {
            System.out.println(e.toString());
        }
    }
}

此外，我注意到其他一些使用KeyFactory生成密钥的示例。 谁能告诉我使用KeyFactory和我使用过的东西之间的区别吗？

Answer 1

您不能将密文切成任意的块！

由于您专门要求不涉及对称算法的普通RSA（我强烈建议您反对！），因此需要执行以下操作：

1. 找出RSA配置的最大有效负载大小 。
2. 将您的纯文本分割成这种大小的块
3. 单独加密每个块， 不要简单地将它们串联起来并丢弃块边界！

解密期间：

1. 使用加密后的原始大小将每个密文块传递给解密函数。 不要追加任何数据，也不要创建“ substrings” 。
2. 连接结果纯文本。

---

理想情况下，您应该使用混合加密方案：

1. 生成一个加密密钥（ encKey ）
2. 使用带有encKey的对称算法加密图像
3. 使用带有RSA的pubKey加密encKey

可以在不同的操作模式中使用对称密码，从而避免了这种长度限制。

Answer 2

首先，首先将图像编码为基数64是绝对没有意义的。现代密码的输入由字节组成，图像已经是字节。 如果您要存储一个字符串，则可能需要对密文进行64位编码。

输入块的大小确实为190字节。 您可以在此处看到RSA / OAEP的表格（别忘了投票！）。 我不确定在这种情况下为什么要使用189。 但是我的代码是通用的。 输出块大小只是RSA的密钥大小，因为它已显式转换为以字节为单位的密钥大小（即使可能更小）。

在解密过程中，您将密文转换为字符串。 但是，Java中的字符串解码是有损的； 如果解码器找到了一个不代表字符的字节，那么它会被静默丢弃。 因此，这将不会（始终有效），例如会导致BadPaddingException 。 没关系，我们可以保留二进制密文。

因此，事不宜迟，请看一些代码。 请注意，以每块66个字节的形式扩展密文，并且主要是解密的性能较差。 强烈建议在混合密码系统中将AES与RSA结合使用（对于这个问题，这不是第一次）。

import java.io.ByteArrayOutputStream;
import java.nio.charset.StandardCharsets;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.util.Arrays;

import javax.crypto.Cipher;

public class Tester {

    private static final int KEY_SIZE = 2048;
    private static final int OAEP_MGF1_SHA256_OVERHEAD = 66;

    public static KeyPair buildKeyPair() throws NoSuchAlgorithmException {
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
        keyPairGenerator.initialize(KEY_SIZE);
        return keyPairGenerator.generateKeyPair();
    }

    public static void main(String args[]) throws Exception {

        KeyPair keyPair = Tester.buildKeyPair();
        RSAPublicKey pubKey = (RSAPublicKey) keyPair.getPublic();
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();

        // assumes the bitLength is a multiple of 8 (check first!)
        int keySizeBytes = pubKey.getModulus().bitLength() / Byte.SIZE;

        byte[] image = new byte[1000];
        Arrays.fill(image, (byte) 'm'); 

        // --- encryption

        final Cipher enc;
        try {
            enc = Cipher.getInstance("RSA/ECB/OAEPWithSHA-256AndMGF1Padding");
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException("OAEP with MGF-1 using SHA-256 not available in this runtime", e);
        }
        enc.init(Cipher.ENCRYPT_MODE, pubKey);

        int fragmentsize = keySizeBytes - OAEP_MGF1_SHA256_OVERHEAD;

        ByteArrayOutputStream ctStream = new ByteArrayOutputStream();
        int off = 0;
        while (off < image.length) {
            int toCrypt = Math.min(fragmentsize, image.length - off);
            byte[] partialCT = enc.doFinal(image, off, toCrypt);
            ctStream.write(partialCT);
            off += toCrypt;
        }

        byte[] ct = ctStream.toByteArray();

        // --- decryption

        Cipher dec = Cipher.getInstance("RSA/ECB/OAEPWithSHA-256AndMGF1Padding");
        dec.init(Cipher.DECRYPT_MODE, privateKey);

        ByteArrayOutputStream ptStream = new ByteArrayOutputStream();
        off = 0;
        while (off < ct.length) {
            int toCrypt = Math.min(keySizeBytes, ct.length - off);
            byte[] partialPT = dec.doFinal(ct, off, toCrypt);
            ptStream.write(partialPT);
            off += toCrypt;
        }

        byte[] pt = ptStream.toByteArray();

        // mmmm...
        System.out.println(new String(pt, StandardCharsets.US_ASCII));
    }
}