java bouncy castle RSA 4096解密填充错误

我用公钥rsa 4096加密了一个包含“Loliol”的私钥的文件，并尝试解密了两天。然后我得到了填充错误，我尝试了所有方法，我得到了错误

Javax.crypto.BadPaddingException:Decryption error

即使在读取填充上的文档后，我也没有成功：加密工作正常，但解密包含错误

这是我的密码：

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.security.Key;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.Security;

import javax.crypto.Cipher;

import sun.misc.BASE64Encoder;

public class GenerateRSAKeys{


    private Key pubKey;
    private Key privKey;

    public static void main(String[] args)
    {
        String input = "C:\\Users\\toto\\Desktop\\nomFichier_entrant.ext";
        String output = "C:\\Users\\toto\\Desktop\\nomFichier_entrant.ext.enc";
        String dec = "C:\\Users\\toto\\Desktop\\nomFichier_entrant.ext.dec";
        String publicKeyFilename = "C:\\Users\\toto\\Desktop\\HR_pubkey_prd.pem";
        String privateKeyFilename = "C:\\Users\\toto\\Desktop\\PE_privkey_prd.pem";

        GenerateRSAKeys generateRSAKeys = new GenerateRSAKeys();

        /*         if (args.length < 2)
        {
            System.err.println("Usage: java "+ generateRSAKeys.getClass().getName()+
            " Public_Key_Filename Private_Key_Filename");
            System.exit(1);
        }

        publicKeyFilename = args[0].trim();
        privateKeyFilename = args[1].trim(); */
        generateRSAKeys.generate(publicKeyFilename, privateKeyFilename);

        //generateRSAKeys.encrypt(input, output);
        generateRSAKeys.encrypt(input, output);
        generateRSAKeys.decrypt(output, dec);

    }

    private void generate (String publicKeyFilename, String privateFilename){

        try {

            Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider());

            // Create the public and private keys
            KeyPairGenerator generator = KeyPairGenerator.getInstance("RSA", "BC");
            BASE64Encoder b64 = new BASE64Encoder();

            KeyPairGenerator keyGen = KeyPairGenerator.getInstance("RSA");
            /* SecureRandom random = new SecureRandom();

            keyGen.initialize(4096, random);

            KeyPair pair = keyGen.generateKeyPair();
            pubKey = pair.getPublic();
            privKey = pair.getPrivate(); */

            SecureRandom random = createFixedRandom();
            generator.initialize(4096, random);

            KeyPair pair = generator.generateKeyPair();
            pubKey = pair.getPublic();
            privKey = pair.getPrivate();

            System.out.println("publicKey : " + b64.encode(pubKey.getEncoded()));
            System.out.println("privateKey : " + b64.encode(privKey.getEncoded()));

            BufferedWriter out = new BufferedWriter(new FileWriter(publicKeyFilename));
            out.write(b64.encode(pubKey.getEncoded()));
            out.close();

            out = new BufferedWriter(new FileWriter(privateFilename));
            out.write(b64.encode(privKey.getEncoded()));
            out.close();


        }
        catch (Exception e) {
            System.out.println(e);
        }
    }

    public static SecureRandom createFixedRandom()
    {
        return new FixedRand();
    }

    private static class FixedRand extends SecureRandom {

        MessageDigest sha;
        byte[] state;

        FixedRand() {
            try
            {
                this.sha = MessageDigest.getInstance("SHA-1");
                this.state = sha.digest();
            }
            catch (NoSuchAlgorithmException e)
            {
                throw new RuntimeException("can't find SHA-1!");
            }
        }

        public void nextBytes(byte[] bytes){

            int    off = 0;

            sha.update(state);

            while (off < bytes.length)
            {                
                state = sha.digest();

                if (bytes.length - off > state.length)
                {
                    System.arraycopy(state, 0, bytes, off, state.length);
                }
                else
                {
                    System.arraycopy(state, 0, bytes, off, bytes.length - off);
                }

                off += state.length;

                sha.update(state);
            }
        }
    }

    public void encrypt(String input, String output) {
        File outputFile;
        FileInputStream inputStream;
        FileOutputStream outputStream;
        Cipher cipher;
        byte[] inputBytes;
        byte[] outputBytes;

        try {
            outputFile = new File(output);
            inputStream = new FileInputStream(input);
            outputStream = new FileOutputStream(outputFile);
            cipher = Cipher.getInstance("RSA");
            cipher.init(Cipher.ENCRYPT_MODE, pubKey);
            inputBytes = new byte[(int) input.length()];
            inputStream.read(inputBytes);
            outputBytes = cipher.doFinal(inputBytes);
            outputStream.write(outputBytes);

            // System.out.println(new String(inputBytes, "UTF-8"));

            System.out.println("encrypt");
            System.out.println(new String(outputBytes, "UTF-8"));
            System.out.println("fin encrypt");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void decrypt(String input, String output) {
        File outputFile;
        FileInputStream inputStream;
        FileOutputStream outputStream;
        Cipher cipher;
        byte[] inputBytes;
        byte[] outputBytes;

        try {
            outputFile = new File(output);
            inputStream = new FileInputStream(input);
            outputStream = new FileOutputStream(outputFile);
            cipher = Cipher.getInstance("RSA");
            cipher.init(Cipher.DECRYPT_MODE, privKey);
            inputBytes = new byte[(int) input.length()];
            inputStream.read(inputBytes);
            outputBytes = cipher.doFinal(inputBytes);
            outputStream.write(outputBytes);

            // System.out.println(new String(inputBytes, "UTF-8"));

            System.out.println("decrypt");
            System.out.println(new String(outputBytes, "UTF-8"));
            System.out.println("fin decrypt");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

导入java.io.BufferedWriter；
导入java.io.File；
导入java.io.FileInputStream；
导入java.io.FileOutputStream；
导入java.io.FileWriter；
导入java.security.Key；
导入java.security.KeyPair；
导入java.security.KeyPairGenerator；
导入java.security.MessageDigest；
导入java.security.NoSuchAlgorithmException；
导入java.security.SecureRandom；
导入java.security.security；
导入javax.crypto.Cipher；
导入sun.misc.base64编码器；
公共类生成器{
私钥公开密钥；
私钥；
公共静态void main（字符串[]args）
{
String input=“C:\\Users\\toto\\Desktop\\nomFichier\u entrant.ext”；
字符串输出=“C:\\Users\\toto\\Desktop\\nomFichier\u entrant.ext.enc”；
String dec=“C:\\Users\\toto\\Desktop\\nomFichier\u entrant.ext.dec”；
String publicKeyFilename=“C:\\Users\\toto\\Desktop\\HR\u pubkey\u prd.pem”；
String privateKeyFilename=“C:\\Users\\toto\\Desktop\\PE\u privkey\u prd.pem”；
GeneratorSakeys GeneratorSakeys=新的GeneratorSakeys（）；
/*如果（参数长度<2）
{
System.err.println（“用法：java”+generateRSAKeys.getClass（）.getName（）+
“公用密钥文件名专用密钥文件名”）；
系统出口（1）；
}
publicKeyFilename=args[0].trim（）；
privateKeyFilename=args[1].trim（）*/
generate（publicKeyFilename、privateKeyFilename）；
//GeneratorSakeys.加密（输入、输出）；
GeneratorSakeys.加密（输入、输出）；
GeneratorSakeys.decrypt（输出，dec）；
}
private void generate（字符串publicKeyFilename、字符串privateFilename）{
试一试{
addProvider（新org.bouncycastle.jce.provider.BouncyCastleProvider（））；
//创建公钥和私钥
KeyPairGenerator generator=KeyPairGenerator.getInstance（“RSA”、“BC”）；
BASE64Encoder b64=新的BASE64Encoder（）；
KeyPairGenerator keyGen=KeyPairGenerator.getInstance（“RSA”）；
/*SecureRandom=新的SecureRandom（）；
密钥初始化（4096，随机）；
KeyPair=keyGen.generateKeyPair（）；
pubKey=pair.getPublic（）；
privKey=pair.getPrivate（）*/
SecureRandom=createFixedRandom（）；
生成器。初始化（4096，随机）；
KeyPair=generator.generateKeyPair（）；
pubKey=pair.getPublic（）；
privKey=pair.getPrivate（）；
System.out.println（“publicKey:+b64.encode（publicKey.getEncoded（）））；
System.out.println（“privateKey:+b64.encode（privKey.getEncoded（）））；
BufferedWriter out=新的BufferedWriter（新的FileWriter（publicKeyFilename））；
out.write（b64.encode（pubKey.getEncoded（））；
out.close（）；
out=新的BufferedWriter（新的FileWriter（privateFilename））；
out.write（b64.encode（privKey.getEncoded（））；
out.close（）；
}
捕获（例外e）{
系统输出打印ln（e）；
}
}
公共静态SecureRandom createFixedRandom（）
{
返回新的FixedRand（）；
}
私有静态类FixedRand扩展SecureRandom{
沙祖康；
字节[]状态；
FixedRand（）{
尝试
{
this.sha=MessageDigest.getInstance（“sha-1”）；
this.state=sha.digest（）；
}
捕获（无算法异常）
{
抛出新的RuntimeException（“找不到SHA-1！”）；
}
}
public void nextBytes（字节[]字节）{
int off=0；
sha.更新（州）；
while（关闭state.length）
{
数组复制（状态，0，字节，关闭，状态，长度）；
}
其他的
{
System.arraycopy（状态，0，字节，关闭，字节.长度-关闭）；
}
off+=状态长度；
sha.更新（州）；
}
}
}
公共void加密（字符串输入、字符串输出）{
文件输出文件；
文件输入流输入流；
FileOutputStream输出流；
密码；
字节[]输入字节；
字节[]输出字节；
试一试{
outputFile=新文件（输出）；
inputStream=新文件inputStream（输入）；
outputStream=新文件outputStream（outputFile）；
cipher=cipher.getInstance（“RSA”）；
cipher.init（cipher.ENCRYPT_模式，pubKey）；
inputBytes=新字节[（int）input.length（）]；
inputStream.read（inputBytes）；
outputBytes=cipher.doFinal（inputBytes）；
outputStream.write（outputBytes）；
//System.out.println（新字符串（inputBytes，“UTF-8”）；
System.out.println（“加密”）；
System.out.println（新字符串（outputBytes，“UTF-8”）；
System.out.println（“fin加密”）；
}捕获（例外e）{
e、 printStackTrace（）；
}
}
公共无效解密（字符串输入、字符串输出）{
文件输出文件；
文件输入流输入流；
FileOutputStream输出流；
密码；
字节[]输入字节；
字节[]输出字节；
试一试{
输出
File inputFile = new File(input);
FileInputStream inputStream = new FileInputStream(inputFile);
FileOutputStream outputStream = new FileOutputStream(output);
byte[] inputBytes = new byte[(int) inputFile.length()];

int readBytes = inputStream.read(inputBytes);
byte[] outputBytes = cipher.doFinal(inputBytes, 0, readBytes);

public void encrypt(String input, String output) {
    File inputFile;
    FileInputStream inputStream;
    FileOutputStream outputStream;
    Cipher cipher;
    byte[] inputBytes;
    byte[] outputBytes;

    try {
        System.out.println("encrypt");

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

        inputFile = new File(input);
        inputStream = new FileInputStream(inputFile);
        outputStream = new FileOutputStream(output);
        inputBytes = new byte[(int) input.length()];
        int readBytes = inputStream.read(inputBytes);
        outputBytes = cipher.doFinal(inputBytes, 0, readBytes);
        outputStream.write(outputBytes);

        System.out.println("fin encrypt");

        inputStream.close();
        outputStream.close();
    } catch (Exception e) {
        e.printStackTrace();
    }
}

public void decrypt(String input, String output) {
    File inputFile;
    FileInputStream inputStream;
    FileOutputStream outputStream;
    Cipher cipher;
    byte[] inputBytes;
    byte[] outputBytes;

    try {
        System.out.println("decrypt");

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

        inputFile = new File(input);
        inputStream = new FileInputStream(inputFile);
        outputStream = new FileOutputStream(output);
        inputBytes = new byte[(int) inputFile.length()];
        int readBytes = inputStream.read(inputBytes);
        outputBytes = cipher.doFinal(inputBytes, 0, readBytes);
        outputStream.write(outputBytes);

        System.out.println("Decryption result: " + new String(outputBytes, "UTF-8"));
        System.out.println("fin decrypt");

        inputStream.close();
        outputStream.close();
    } catch (Exception e) {
        e.printStackTrace();
    }
}