package password_test2;

import java.io.*;
import java.nio.file.*;
import java.security.*;
import java.security.spec.*;
import javax.crypto.*;
import java.util.Base64;

public class EncryptionDecryption {

    public static void main(String[] args) {
        try {
            // 生成密钥对并存储到文件
            generateKeyPair("publickey1.txt", "privatekey1.txt");
            generateKeyPair("publickey2.txt", "privatekey2.txt");

            // 读取原始明文
            String plaintext = new String(Files.readAllBytes(Paths.get("plaintext.txt")));

            // 加密明文
            String ciphertext = encrypt(plaintext, "privatekey1.txt");
            Files.write(Paths.get("ciphertext.txt"), ciphertext.getBytes());

            // 解密密文
            String decryptedText = decrypt(ciphertext, "publickey1.txt");
            Files.write(Paths.get("result.txt"), decryptedText.getBytes());
            System.out.println("Decrypted text: " + decryptedText);

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

    /**
     * 生成RSA密钥对并将公钥和私钥分别存储到指定文件中
     *
     * @param publicKeyFile 公钥文件名
     * @param privateKeyFile 私钥文件名
     * @throws Exception 如果发生任何异常
     */
    public static void generateKeyPair(String publicKeyFile, String privateKeyFile) throws Exception {
        // 创建KeyPairGenerator对象，指定算法为RSA
        KeyPairGenerator keyGen = KeyPairGenerator.getInstance("RSA");
        // 初始化KeyPairGenerator对象，密钥长度为2048位
        keyGen.initialize(2048);
        // 生成密钥对
        KeyPair keyPair = keyGen.generateKeyPair();

        // 获取公钥和私钥
        PublicKey publicKey = keyPair.getPublic();
        PrivateKey privateKey = keyPair.getPrivate();

        // 将公钥和私钥分别编码为Base64并写入文件
        Files.write(Paths.get(publicKeyFile), Base64.getEncoder().encode(publicKey.getEncoded()));
        Files.write(Paths.get(privateKeyFile), Base64.getEncoder().encode(privateKey.getEncoded()));
    }

    /**
     * 使用指定的公钥文件加密明文
     *
     * @param plaintext 要加密的明文
     * @param keyFile 公钥文件名
     * @return 加密后的密文
     * @throws Exception 如果发生任何异常
     */
    public static String encrypt(String plaintext, String keyFile) throws Exception {
        // 从文件中读取公钥
        PublicKey publicKey = getPublicKey(keyFile);
        // 创建Cipher对象，指定算法为RSA
        Cipher cipher = Cipher.getInstance("RSA");
        // 初始化Cipher对象为加密模式
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        // 执行加密操作
        byte[] encryptedBytes = cipher.doFinal(plaintext.getBytes());
        // 将加密后的字节数组编码为Base64字符串并返回
        return Base64.getEncoder().encodeToString(encryptedBytes);
    }

    /**
     * 使用指定的私钥文件解密密文
     *
     * @param ciphertext 要解密的密文
     * @param keyFile 私钥文件名
     * @return 解密后的明文
     * @throws Exception 如果发生任何异常
     */
    public static String decrypt(String ciphertext, String keyFile) throws Exception {
        // 从文件中读取私钥
        PrivateKey privateKey = getPrivateKey(keyFile);
        // 创建Cipher对象，指定算法为RSA
        Cipher cipher = Cipher.getInstance("RSA");
        // 初始化Cipher对象为解密模式
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        // 执行解密操作
        byte[] decryptedBytes = cipher.doFinal(Base64.getDecoder().decode(ciphertext));
        // 将解密后的字节数组转换为字符串并返回
        return new String(decryptedBytes);
    }

    /**
     * 从文件中读取公钥
     *
     * @param filename 公钥文件名
     * @return 公钥对象
     * @throws Exception 如果发生任何异常
     */
    private static PublicKey getPublicKey(String filename) throws Exception {
        // 从文件中读取字节数组
        byte[] keyBytes = Files.readAllBytes(Paths.get(filename));
        // 创建X509EncodedKeySpec对象
        X509EncodedKeySpec spec = new X509EncodedKeySpec(Base64.getDecoder().decode(keyBytes));
        // 获取KeyFactory对象，指定算法为RSA
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        // 生成并返回公钥
        return keyFactory.generatePublic(spec);
    }

    /**
     * 从文件中读取私钥
     *
     * @param filename 私钥文件名
     * @return 私钥对象
     * @throws Exception 如果发生任何异常
     */
    private static PrivateKey getPrivateKey(String filename) throws Exception {
        // 从文件中读取字节数组
        byte[] keyBytes = Files.readAllBytes(Paths.get(filename));
        // 创建PKCS8EncodedKeySpec对象
        PKCS8EncodedKeySpec spec = new PKCS8EncodedKeySpec(Base64.getDecoder().decode(keyBytes));
        // 获取KeyFactory对象，指定算法为RSA
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        // 生成并返回私钥
        return keyFactory.generatePrivate(spec);
    }
}


   

// 读取原始明文
String plaintext = new String(Files.readAllBytes(Paths.get("plaintext.txt")));

// 加密明文
String ciphertext = encrypt(plaintext, "privatekey1.txt");
Files.write(Paths.get("ciphertext.txt"), ciphertext.getBytes());

// 解密密文
String decryptedText = decrypt(ciphertext, "publickey1.txt");
Files.write(Paths.get("result.txt"), decryptedText.getBytes());
System.out.println("Decrypted text: " + decryptedText);

// 加密明文
String ciphertext = encrypt(plaintext, "privatekey1.txt");
Files.write(Paths.get("ciphertext.txt"), ciphertext.getBytes());

// 解密密文
String decryptedText = decrypt(ciphertext, "publickey2.txt");
Files.write(Paths.get("result.txt"), decryptedText.getBytes());
System.out.println("Decrypted text: " + decryptedText);

// 加密明文
 String ciphertext = encrypt(plaintext, "publickey1.txt");
 Files.write(Paths.get("ciphertext.txt"), ciphertext.getBytes());

 // 解密密文
 String decryptedText = decrypt(ciphertext, "privatekey2.txt");
 Files.write(Paths.get("result.txt"), decryptedText.getBytes());
 System.out.println("Decrypted text: " + decryptedText);

String ciphertext = encrypt(plaintext, "privatekey1.txt");
 Files.write(Paths.get("ciphertext.txt"), ciphertext.getBytes());

 // 解密密文
 String decryptedText = decrypt(ciphertext, "privatekey2.txt");
 Files.write(Paths.get("result.txt"), decryptedText.getBytes());
 System.out.println("Decrypted text: " + decryptedText);