我正在Java学习RSA公钥/私钥对加密。

我有下面的代码在工作。 它生成一个私有的&； 公钥对，将密钥写入磁盘，用磁盘上的公钥对字符串进行加密，用磁盘上的私钥对字符串进行解密，然后输出解密后的字符串。

一切都很顺利。

接下来的事情是，我希望密钥文件是可读的“-------开始RSA私钥------”类型的密钥文件。。。所以我编写了方法saveKeystodiskBase64。

问题是，当我使用SaveKeystodiskBase64编写文件时，读取密钥文件的方法会失败。 即LoadPrivateKey和LoadPublicKey无法读取Base64文件。

我错过了什么？

public class EncryptionTest1 {


    public void execute() throws Exception {
        
        String filename = "test1";
        
        KeyPair keyPair = EncryptionUtil.generateKeyPair();
        EncryptionUtil.saveKeysToDisk(filename, keyPair);
        // EncryptionUtil.saveKeysToDiskBase64(filename, keyPair);

        String pvtKeyFilename = filename+".key";
        String pubKeyFilename = filename+".pub";
        
        PrivateKey privateKey = EncryptionUtil.loadPrivateKey(pvtKeyFilename);
        byte[] bPrivateKey = privateKey.getEncoded();

        PublicKey publicKey = EncryptionUtil.loadPublicKey(pubKeyFilename);
        byte[] bPublicKey = publicKey.getEncoded();

        String sOriginal = "hi this is plain text";

        byte[] encryptedData = EncryptionUtil.encrypt(bPublicKey, sOriginal.getBytes());
        byte[] decryptedData = EncryptionUtil.decrypt(bPrivateKey, encryptedData);
        
        String sEncrypted = new String(encryptedData);
        String sDecrypted = new String(decryptedData);
        
        System.out.println("sOriginal = "+sOriginal);
        System.out.println("sEncrypted = "+sEncrypted);
        System.out.println("sDecryptedData = "+sDecrypted);

    }
    
    
    public static void main(String[] args) {
        try {
            new EncryptionTest1().execute();
        } catch (Exception x) {
            x.printStackTrace();
        }
    }
    
}

。。。

public class EncryptionUtil {

    
    private static final String ALGORITHM = "RSA";

    
    public static KeyPair generateKeyPair() throws NoSuchAlgorithmException, NoSuchProviderException {

        KeyPairGenerator keyGen = KeyPairGenerator.getInstance(ALGORITHM);

        SecureRandom random = SecureRandom.getInstance("SHA1PRNG", "SUN");

        // 2048 is keysize
        keyGen.initialize(2048, random);

        KeyPair generateKeyPair = keyGen.generateKeyPair();
        
        return generateKeyPair;
    }
    
    public static void saveKeysToDisk(String name, KeyPair keyPair) {
        try {
            String privateFileName = name+".key";
            FileOutputStream out1 = new FileOutputStream(privateFileName);
            out1.write(keyPair.getPrivate().getEncoded());
            out1.close();
             
            String publicFileName = name+".pub";
            FileOutputStream out2 = new FileOutputStream(publicFileName);
            out2.write(keyPair.getPublic().getEncoded());
            out2.close();
        } catch (Exception x) {
            x.printStackTrace();
        }
    }


    public static void saveKeysToDiskBase64(String name, KeyPair keyPair) {
        try {

            Base64.Encoder encoder = Base64.getEncoder();
             
            String privateFileName = name+".key";
            Writer out = new FileWriter(privateFileName);
            out.write("-----BEGIN RSA PRIVATE KEY-----\n");
            out.write(encoder.encodeToString(keyPair.getPrivate().getEncoded()));
            out.write("\n-----END RSA PRIVATE KEY-----\n");
            out.close();            

            String publicFileName = name+".pub";
            Writer out2 = new FileWriter(publicFileName);
            out2.write("-----BEGIN RSA PUBLIC KEY-----\n");
            out2.write(encoder.encodeToString(keyPair.getPublic().getEncoded()));
            out2.write("\n-----END RSA PUBLIC KEY-----\n");
            out2.close();           

        } catch (Exception x) {
            x.printStackTrace();
        }
    }

    
    public static PrivateKey loadPrivateKey(String keyFile) {
        PrivateKey pvt = null;
        try {
            /* Read all bytes from the private key file */
            Path path = Paths.get(keyFile);
            byte[] bytes = Files.readAllBytes(path);

            /* Generate private key. */
            PKCS8EncodedKeySpec ks = new PKCS8EncodedKeySpec(bytes);
            KeyFactory kf = KeyFactory.getInstance("RSA");
            pvt = kf.generatePrivate(ks);
        } catch (Exception x) {
            x.printStackTrace();
        }
        
        return pvt;
    }
    
    public static PublicKey loadPublicKey(String keyFile) {
        PublicKey pub = null;
        try {
            /* Read all the public key bytes */
            Path path = Paths.get(keyFile);
            byte[] bytes = Files.readAllBytes(path);
            
            /* Generate public key. */
            X509EncodedKeySpec ks = new X509EncodedKeySpec(bytes);
            KeyFactory kf = KeyFactory.getInstance("RSA");
            pub = kf.generatePublic(ks);
        } catch (Exception x) {
            x.printStackTrace();
        }
        return pub;
    }
    
    
    
    


    public static byte[] encrypt(byte[] publicKey, byte[] inputData) throws Exception {

        PublicKey key = KeyFactory.getInstance(ALGORITHM).generatePublic(new X509EncodedKeySpec(publicKey));

        Cipher cipher = Cipher.getInstance(ALGORITHM);
        cipher.init(Cipher.ENCRYPT_MODE, key);

        byte[] encryptedBytes = cipher.doFinal(inputData);

        return encryptedBytes;
    }

    public static byte[] decrypt(byte[] privateKey, byte[] inputData) throws Exception {

        PrivateKey key = KeyFactory.getInstance(ALGORITHM).generatePrivate(new PKCS8EncodedKeySpec(privateKey));

        Cipher cipher = Cipher.getInstance(ALGORITHM);
        cipher.init(Cipher.DECRYPT_MODE, key);

        byte[] decryptedBytes = cipher.doFinal(inputData);

        return decryptedBytes;
    }
    
}