如何在Java非对称加密中保存和重用密钥对？

我已经编写了生成密钥对的代码，但是我想知道是否有办法保存和重用它们

以下是生成该对的代码：

公共静态void main（字符串[]args）引发异常{

    String plainText = "Hello world";

    Map<String, Object> keys = getRSAKeys();

    PrivateKey privateKey = (PrivateKey) keys.get("private");
    PublicKey publicKey = (PublicKey) keys.get("public");

    System.out.println(privateKey.getEncoded());

    System.out.println(publicKey.getEncoded());



    String encrypted = encryptMessage(plainText, privateKey);


    System.out.println(encrypted);

    String decrypted = decryptMessage(plainText, publicKey, encrypted);

    System.out.println(decrypted);

}

private static Map<String, Object> getRSAKeys() throws Exception {

    KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
    keyPairGenerator.initialize(2048);
    KeyPair keyPair = keyPairGenerator.generateKeyPair();
    PrivateKey privateKey = keyPair.getPrivate();
    PublicKey publicKey = keyPair.getPublic();
    Map<String, Object> keys = new HashMap<String, Object>();
    keys.put("private", privateKey);
    keys.put("public", publicKey);

    return keys;

}

String plainText=“Hello world”；
映射键=getRSAKeys（）；
PrivateKey PrivateKey=（PrivateKey）keys.get（“private”）；
PublicKey PublicKey=（PublicKey）keys.get（“public”）；
System.out.println（privateKey.getEncoded（））；
System.out.println（publicKey.getEncoded（））；
字符串加密=加密消息（明文，私钥）；
System.out.println（加密）；
字符串解密=解密消息（明文、公钥、加密）；
System.out.println（已解密）；
}
私有静态映射getRSAKeys（）引发异常{
KeyPairGenerator KeyPairGenerator=KeyPairGenerator.getInstance（“RSA”）；
keyPairGenerator.initialize（2048）；
KeyPair KeyPair=keyPairGenerator.generateKeyPair（）；
PrivateKey PrivateKey=keyPair.getPrivate（）；
PublicKey PublicKey=keyPair.getPublic（）；
映射键=新的HashMap（）；
密钥。put（“私有”，privateKey）；
密钥。put（“public”，publicKey）；
返回键；
}

——很好的切入点

此外，下面是一些示例代码，可以完全按照您的要求执行：

package mx.playground.security;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.file.Files;
import java.security.KeyFactory;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;

import javax.crypto.Cipher;

public class AppForStackOverflow {

    public static final int KEY_SIZE = 2048;

    public static final String PUBLIC_KEY_X509 = "C:\\workspace\\rsa-pair\\public-key";
    public static final String PUBLIC_KEY_PKCS1 = "C:\\workspace\\rsa-pair\\public-key-pkcs1";
    public static final String PUBLIC_KEY_PEM = "C:\\workspace\\rsa-pair\\public-key-pem";

    public static final String PRIVATE_KEY_PKCS8 = "C:\\workspace\\rsa-pair\\private-key";
    public static final String PRIVATE_KEY_PKCS1 = "C:\\workspace\\rsa-pair\\private-key-pkcs1";
    public static final String PRIVATE_KEY_PEM = "C:\\workspace\\rsa-pair\\private-key-pem";

    public static final String SIGNATURE_PATH = "C:\\workspace\\rsa-pair\\signature";

    public static final String PRIVATE_KEY_PATH = PRIVATE_KEY_PKCS8;
    public static final String PUBLIC_KEY_PATH = PUBLIC_KEY_X509;

    public static void main(String[] args) {
        generateRsaKeysPair();
        encryptDecryptTest();

        // symmetric encryption example, use it to store your Private Key in safe manner
        String message = "test message";
        String rightPass = "0123456789ABCDEF"; // for AES password should be at least 16 chars 
        String wrongPass = "zzz";

        byte[] encryptedMessage = symmetricEncrypt(message.getBytes(), rightPass);
        System.out.print(new String(encryptedMessage));

        byte[] decryptedMessage = symmetricDecrypt(encryptedMessage, rightPass);
        System.out.println(new String(decryptedMessage));

    }       

    public static void generateRsaKeysPair() {
        try {
            KeyPairGeneratorJdk kpg = new KeyPairGeneratorJdk(KEY_SIZE, "RSA");

            PublicKey  publicKey  = kpg.getPublicKey();
            PrivateKey privateKey = kpg.getPrivateKey();

            save(PUBLIC_KEY_PATH,  publicKey.getEncoded());
            save(PRIVATE_KEY_PATH, privateKey.getEncoded());
        } catch (Exception e) {
            throw new RuntimeException("Failed to execute generateRsaKeysPair()", e);           
        }
    }

    public static void encryptDecryptTest() {
        try {
            byte[] privateKeyBytes = read(PRIVATE_KEY_PATH);
            byte[] publicKeyBytes = read(PUBLIC_KEY_PATH);

            KeyFactory kf = KeyFactory.getInstance("RSA");
            PKCS8EncodedKeySpec privateKeySpec = new PKCS8EncodedKeySpec(privateKeyBytes);
            PrivateKey privateKey = kf.generatePrivate(privateKeySpec);

            X509EncodedKeySpec spec = new X509EncodedKeySpec(publicKeyBytes);
            PublicKey publicKey = kf.generatePublic(spec);

            Cipher cipher = Cipher.getInstance("RSA");

            // doing encryption
            String message = "test message";
            cipher.init(Cipher.ENCRYPT_MODE, publicKey);
            byte[] encodedMessage = cipher.doFinal(message.getBytes("UTF-8"));
            System.out.println("ENCRYPTED: " + new String(encodedMessage));

            // doing decryption
            cipher.init(Cipher.DECRYPT_MODE, privateKey);
            byte[] decodedMessage = cipher.doFinal(encodedMessage);
            System.out.println("DECRYPTED: " + new String(decodedMessage));
        } catch (Exception e) {
            throw new RuntimeException("Failed to execute encryptDecryptTest()", e);
        }
    }

    private static void save(String path, byte[] data) {
        try {
            File file = new File(path);
            file.getParentFile().mkdirs();

            try (FileOutputStream fos = new FileOutputStream(file)){
                fos.write(Base64.getEncoder().encode(data));
                fos.flush();
            };
        } catch (IOException e) {
            throw new RuntimeException("Failed to save data to file: " + path, e);
        }
    }

    private static byte[] read(String path) {
        try {
            return Base64.getDecoder().decode(Files.readAllBytes(new File(path).toPath()));
        } catch (IOException e) {
            throw new RuntimeException("Failed to read data from file: " + path, e);
        }
    }   

    /*
     * Use this to encrypt your private key before saving it to disk  
     */
    public static byte[] symmetricEncrypt(byte[] data, String password) {
        try {
            SecretKeySpec secretKey = new SecretKeySpec(password.getBytes(), "AES");
            Cipher cipher = Cipher.getInstance("AES");
            cipher.init(Cipher.ENCRYPT_MODE, secretKey);
            byte[] result = cipher.doFinal(data);
            return result;
        } catch (Exception e) {
            throw new RuntimeException("Failed to execute symmetricEncrypt()", e);
        }
    }

    public static byte[] symmetricDecrypt(byte[] data, String password) {
        try {
            SecretKeySpec secretKey = new SecretKeySpec(password.getBytes(), "AES");
            Cipher cipher = Cipher.getInstance("AES");
            cipher.init(Cipher.DECRYPT_MODE, secretKey);
            byte[] result = cipher.doFinal(data);
            return result;
        } catch (Exception e) {
            throw new RuntimeException("Failed to execute symmetricEncrypt()", e);
        }
    }

}

---

当然不管怎么说，只要保留数据就行了。在程序的生命周期内，只需保留引用即可。在程序的生命周期之外-嗯，它们是可序列化的，所以序列化它们。（当然，你必须担心序列化密钥的安全性…）放在一边：当你可以返回

KeyPair

对象时，为什么要将它们放在地图中？谢谢Andy，你会怎么做呢？使用你最喜欢的搜索引擎查找关于序列化的教程。将它们保存在密钥库中。这就是它的用途。只是为了好玩，我添加了一些代码，用pass对私钥进行对称加密，使它不那么不安全，更容易接受。