RSA-AES Decryption Issue - javax.crypto.BadPaddingException: Decryption error

I am in need to convert the python code to java code for RSA-AES Decryption logic. They have provided RSA Encrypted string and private key as a PEM file format. we need to implement the same decryption in java code.

Here , I have included the python code, (this we have to convert into java)

import base64

from Crypto.Cipher import AES

from cryptography.hazmat.primitives import hashes

from cryptography.hazmat.primitives.asymmetric import padding

from Crypto.PublicKey import RSA

from Crypto.Cipher import PKCS1_v1_5

from cryptography.hazmat.backends import default_backend

from cryptography.hazmat.primitives import serialization

encrypted = 'gBTI3T5KP8CG23_DLM7lVo9--pEQcoHaL2YxuhHqmv_guahHuOeDPQQiV3-yxXK4JXacIjqv7BL7QpTzq9v8HyK4P_f0PYFTH4RjnM_IYnAQPZt0ey2m2ckkvfuuAqeXvPEFoQtPfLPqqAokYzhH2O5K-VYth0tfTEjWGGNH7ukQjcjh3fUDneFBH4MVYuzGACRtG3gPTvCHnAuzAkA6UWfErXbh-17ZsBxpw-9wdcRtJ2DTE8rOZcpcT4NwXtURLDL6fl3eXaQFQA6BMZ2k1Iv19zjUD7WyN6NUZwQYdtMBq3PUMBd-uMNmB8YEb9sV4fEixbiZIS4j0y2gFCf0JrZXq7n9Jtv7_WTL0_jxoeysVauc2u3rc31jRtzHS6m1vTlg4qAcq390nk4m_QJyLq1RrvsWnyg6HjVpjSwSCEgZj441WWENWAaH0Tb2JhWosu53eiRTbjGivAKa0SUxpYW6b85DqW9jmYs9D9JrMwzVllmF6KaFa6lL3C97VZGmPZChUihqCvzp8tpxx7EPuPXloyFJaH3_oMW8PgQL0uBuCLfFt5pdxAp4QqEOe_z19IS27PSdJfFwZrk8DM3cLQEn__30EsnVC1e1fGrqz3Xh_Yvw-1kBZuer3YBpw43lIachaATy43EuVvM2gl1ppasBZQwMQWTWkJqrTyQBUmQ='

decoded = base64.urlsafe_b64decode(encrypted)

print('decode : ', decoded)

print('--------------- Started RSA Decryption ----------------------')

with open("./t2.pem", "rb") as key_file:

private_key = serialization.load_pem_private_key(

key_file.read(),

password=None,

backend=default_backend()

)

original_message = private_key.decrypt(

decoded,

padding.OAEP(

mgf=padding.MGF1(algorithm=hashes.SHA256()),

algorithm=hashes.SHA256(),

label="OAEP Encrypted"

)

)

print("RSA Decrypted Message",original_message)

print('--------------- Started AES Decryption ----------------------')

value = str(original_message)

key = b'1004063899047190'

value = base64.b64decode(value + '=' * (4 - len(value) % 4), '-_')

iv, value = value[:AES.block_size], value[AES.block_size:]

remainder = len(value) % 16

padded_value = value + '\0' * (16 - remainder)

cipher = AES.new(key, AES.MODE_CFB, iv, segment_size=128)

msg = cipher.decrypt(padded_value)[:len(value)]

print("message -- ",msg)


print("message -- ",msg)

I am getting the following error while tried "to convert the encrypted text to RSA decryption" in java code,

I have tried many things using "io.netty" ,"BouncyCastle" provider, apache BASE64, JavaUtil Base64.. etc all those stufs.

package MMDemo.TarCopyJen2Master;

import java.io.BufferedReader;

import java.io.FileReader;

import java.io.IOException;

import java.security.GeneralSecurityException;

import java.security.KeyFactory;

import java.security.KeyPair;

import java.security.KeyPairGenerator;

import java.security.PrivateKey;

import java.security.PublicKey;
import java.security.Security;
import java.util.Base64;

import java.security.interfaces.RSAPrivateKey;

import java.security.spec.MGF1ParameterSpec;

import java.security.spec.PKCS8EncodedKeySpec;

import javax.crypto.Cipher;

import javax.crypto.SecretKey;

import javax.crypto.spec.OAEPParameterSpec;

import javax.crypto.spec.PSource;

import javax.crypto.spec.SecretKeySpec;

import org.bouncycastle.jce.provider.BouncyCastleProvider;

public class PublickeyTest1 {

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

        Security.addProvider(new BouncyCastleProvider());
        String rsaEncrypted1 = "gBTI3T5KP8CG23_DLM7lVo9--pEQcoHaL2YxuhHqmv_guahHuOeDPQQiV3-yxXK4JXacIjqv7BL7QpTzq9v8HyK4P_f0PYFTH4RjnM_IYnAQPZt0ey2m2ckkvfuuAqeXvPEFoQtPfLPqqAokYzhH2O5K-VYth0tfTEjWGGNH7ukQjcjh3fUDneFBH4MVYuzGACRtG3gPTvCHnAuzAkA6UWfErXbh-17ZsBxpw-9wdcRtJ2DTE8rOZcpcT4NwXtURLDL6fl3eXaQFQA6BMZ2k1Iv19zjUD7WyN6NUZwQYdtMBq3PUMBd-uMNmB8YEb9sV4fEixbiZIS4j0y2gFCf0JrZXq7n9Jtv7_WTL0_jxoeysVauc2u3rc31jRtzHS6m1vTlg4qAcq390nk4m_QJyLq1RrvsWnyg6HjVpjSwSCEgZj441WWENWAaH0Tb2JhWosu53eiRTbjGivAKa0SUxpYW6b85DqW9jmYs9D9JrMwzVllmF6KaFa6lL3C97VZGmPZChUihqCvzp8tpxx7EPuPXloyFJaH3_oMW8PgQL0uBuCLfFt5pdxAp4QqEOe_z19IS27PSdJfFwZrk8DM3cLQEn__30EsnVC1e1fGrqz3Xh_Yvw-1kBZuer3YBpw43lIachaATy43EuVvM2gl1ppasBZQwMQWTWkJqrTyQBUmQ=";
        PrivateKey privateKey = getPrivateKey("D:/Infosys/Decrpyt/EncryptDec/private_key.pem");
        String rsaDecrypted = decrypt(rsaEncrypted1, privateKey);
        System.out.println("RSA Decrypted Text == " + rsaDecrypted);
    }

    public static String decrypt(String cipherText, PrivateKey privateKey)
            throws IOException, GeneralSecurityException {
        byte[] decodedCipherText = Base64.getUrlDecoder().decode(cipherText);

        System.out.println("Decoded Cipher text == " + decodedCipherText.toString());

        OAEPParameterSpec oaepParams = new OAEPParameterSpec(

                "SHA-256", "MGF1", new MGF1ParameterSpec("SHA-256"), PSource.PSpecified.DEFAULT);

        Cipher cipher = Cipher.getInstance("RSA/ECB/OAEPWithSHA-256AndMGF1Padding");

        cipher.init(Cipher.DECRYPT_MODE, privateKey);

        // cipher.init(Cipher.DECRYPT_MODE, privateKey);

        System.out.println("algo " + cipher.getAlgorithm());

        System.out.println("cipherText == " + cipherText);

        return new String(cipher.doFinal(decodedCipherText), "UTF-8");

    }

    private static String getKey(String filename) throws IOException {

        // Read key from file

        String strKeyPEM = "";

        BufferedReader br = new BufferedReader(new FileReader(filename));

        String line;

        while ((line = br.readLine()) != null) {

            strKeyPEM += line;// + "n";

        }

        br.close();

        return strKeyPEM;

    }

    public static RSAPrivateKey getPrivateKey(String filename) throws IOException, GeneralSecurityException {

        String privateKeyPEM = getKey(filename);

        System.out.println("PrivateKeyPem == " + privateKeyPEM);

        return getPrivateKeyFromString(privateKeyPEM);

    }

    public static RSAPrivateKey getPrivateKeyFromString(String key) throws IOException, GeneralSecurityException {

        String privateKeyPEM = key;

        // Remove the first and last lines

        privateKeyPEM = privateKeyPEM.replace("-----BEGIN RSA PRIVATE KEY-----", "");

        privateKeyPEM = privateKeyPEM.replace("-----END RSA PRIVATE KEY-----", "");

        privateKeyPEM = privateKeyPEM.replace("-----BEGIN PRIVATE KEY-----", "");

        privateKeyPEM = privateKeyPEM.replace("-----END PRIVATE KEY-----", "");

        System.out.println("privatekey pem after removal == " + privateKeyPEM);

        byte[] encoded = Base64.getDecoder().decode(privateKeyPEM); // for util base64

        KeyFactory kf = KeyFactory.getInstance("RSA");

        RSAPrivateKey privKey = (RSAPrivateKey) kf.generatePrivate(new PKCS8EncodedKeySpec(encoded));

        System.out.println("RSA Private Key after encoded: " + privKey);
        return privKey;

    }

}

This is error I am getting while try to convert the encrypted text to RSA Decryption.

Exception in thread "main" javax.crypto.BadPaddingException: Decryption error
    at sun.security.rsa.RSAPadding.unpadOAEP(RSAPadding.java:502)
    at sun.security.rsa.RSAPadding.unpad(RSAPadding.java:296)
    at com.sun.crypto.provider.RSACipher.doFinal(RSACipher.java:363)
    at com.sun.crypto.provider.RSACipher.engineDoFinal(RSACipher.java:389)
    at javax.crypto.Cipher.doFinal(Cipher.java:2164)
    at com.infy.rsaaes.RSAAESEncryptDecrypt.PublickeyTest1.decrypt(PublickeyTest1.java:129)
    at com.infy.rsaaes.RSAAESEncryptDecrypt.PublickeyTest1.main(PublickeyTest1.java:79)

here I have given the private key (PEM) file format to decrypt the text.

If we use the same key in that python code, It will work. Could anyone help on this?

Solution

As already mentioned in the comment, there is something wrong with the padding:

Although an OAEPParameterSpec-instance (oaepParams) is created, it is not used anywhere! oaepParams must be passed as third parameter in the Cipher#init-call.
OAEP uses a label that by default is an empty byte-array (PSource.PSpecified.DEFAULT). Although it is rather unusual, the Python-code doesn't use that default (i.e. the empty byte-array), but a custom byte-sequence (more precisely, the string OAEP Encrypted, UTF-8 encoded). Therefore, in the OAEPParameterSpec- constructor-call PSource.PSpecified.DEFAULT must be replaced by new PSource.PSpecified("OAEP Encrypted".getBytes(StandardCharsets.UTF_8)).

For a more detailed description of OAEP and PSource.PSpecified see e.g. here and here. If both bugs are fixed, the RSA-decryption of the Java-code corresponds to that of the Python-code (UQQtMe0oUzkguQLzvcBcJMAvmsx2XWU6G-CMZtV1dR0qtu2LXwE=). By the way, the Java-code contains only the RSA-decryption portion of the Python-code.