【Java】Java实现非对称加密（RSA算法）

1、 简介

非对称加密算法又叫做现代加密算法

• 非对称加密，有两个秘钥，一个公钥一个私钥.公钥和私钥是一对，叫做密钥对
• 如果使用公钥加密必须使用私钥解密
• 如果使用私钥加密必须使用公钥解密
• 处理数据的速度较慢，因为安全级别高

2、 对称加密算法的对比

• 优点：其安全性更好，对称加密的通信双方使用相同的秘钥，如果一方的秘钥遭泄露，那么整个通信就会被破解。而非对称加密使用一对秘钥，一个用来加密，一个用来解密，而且公钥是公开的，秘钥是自己保存的，不需要像对称加密那样在通信之前要先同步秘钥。
• 缺点：非对称加密的缺点是加密和解密花费时间长、速度慢，只适合对少量数据进行加密。

3、 常用的非对称加密算法

RSA算法和ECC算法

• RSA算法基于一个十分简单的数论事实：将两个大质数（素数）相乘十分容易，但是想要对其乘积进行因式分解却极其困难，因此可以将乘积公开作为加密密钥。比如：取两个简单的质数：89、97，得到两者乘积很简单8633；但是要想对8633进行因式分解，其工作量成几何增加。

4、 Java实现RSA算法

package com.lh.basecryptology.rsa;

import com.sun.org.apache.xerces.internal.impl.dv.util.Base64;
import org.apache.commons.io.FileUtils;

import javax.crypto.Cipher;
import java.io.File;
import java.nio.charset.Charset;
import java.security.*;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;

/**
 * 非对称加密 RSA算法
 */
public class RSADemo {
    public static void main(String[] args) throws Exception {
        
        // 算法
        String algorithm ="RSA";

        // 创建密钥对
        // generatorKey2File(algorithm,"a.pub","b.pri");
        String text = "十里洋场，遍地黄金！";
        PrivateKey privateKey = getPrivateKey("b.pri", algorithm);
        PublicKey publicKey = getPublicKey("a.pub", algorithm);

        String encrypt = encryptRSA(algorithm, privateKey, text);
        System.out.println("密文：" + encrypt);
        String decrypt = decryptRSA(algorithm, publicKey, encrypt);
        System.out.println("明文：" + decrypt);


    }

    /**
     * 保存公钥和私钥到文件中
     * @param algorithm 加密算法
     * @param publicPath 公钥路径
     * @param privatePath 私钥路径
     */
    private static void generatorKey2File(String algorithm, String publicPath, String privatePath) throws Exception {

        // 创建密钥对生成器
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
        // 生成密钥对
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        // 生成私钥
        PrivateKey privateKey = keyPair.getPrivate();
        // 生成私钥
        PublicKey publicKey = keyPair.getPublic();
        // 生成私钥字节数组
        byte[] privateKeyEncoded = privateKey.getEncoded();
        // 生成公钥的字节数组
        byte[] publicKeyEncoded = publicKey.getEncoded();
        // s使用Base64进行编码
        String privateKeyEncodedString = Base64.encode(privateKeyEncoded);
        String publicKeyEncodedString = Base64.encode(publicKeyEncoded);
        System.out.println(privateKeyEncodedString);
        System.out.println(publicKeyEncodedString);
        // 把公钥和私钥保存到文件中
        FileUtils.writeStringToFile(new File(publicPath),publicKeyEncodedString,Charset.forName("UTF-8"));
        FileUtils.writeStringToFile(new File(privatePath),privateKeyEncodedString,Charset.forName("UTF-8"));
    }

    /**
     * RSA 加密
     * @param algorithm 加密算法
     * @param key 密钥
     * @param text 原文
     * @return 密文
     * @throws Exception 异常
     */
    private static String encryptRSA(String algorithm,Key key,String text) throws Exception {
        // 创建加密对象
        Cipher cipher = Cipher.getInstance(algorithm);
        // 对加密进行初始化 第一个参数是加密模式，第二个参数是你想用的公钥加密还是私钥加密
        cipher.init(Cipher.ENCRYPT_MODE,key);
        byte[] bytes = cipher.doFinal(text.getBytes());
        return Base64.encode(bytes);
    }

    /**
     * RSA 解密
     * @param algorithm 加密算法
     * @param key 密钥
     * @param text 密文
     * @return 明文
     * @throws Exception 异常
     */
    private static String decryptRSA(String algorithm,Key key,String text) throws Exception {
        // 创建加解密对象
        Cipher cipher = Cipher.getInstance(algorithm);
        // 对解密进行初始化 第一个参数是加密模式，第二个参数是你想用的公钥解密还是私钥解密
        cipher.init(Cipher.DECRYPT_MODE,key);
        byte[] bytes = cipher.doFinal(Base64.decode(text));
        return new String(bytes);
    }

    /**
     * 读取私钥
     * @param privatePath 私钥路径
     * @param algorithm 算法
     * @return 私钥
     */
    public static PrivateKey getPrivateKey(String privatePath, String algorithm) throws Exception {
        // 从文件中读取私钥
        String privateKeyString = FileUtils.readFileToString(new File(privatePath), Charset.defaultCharset());
        // 创建key的工厂
        KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
        // 创建私钥key的规则
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(Base64.decode(privateKeyString));
        // 返回私钥对象
        return keyFactory.generatePrivate(keySpec);
    }

    /**
     * 读取公钥
     * @param publicPath 公钥路径
     * @param algorithm 算法
     * @return 公钥
     * @throws Exception 异常
     */
    public static PublicKey getPublicKey(String publicPath, String algorithm) throws Exception {
        // 从文件中读取公钥
        String publicKeyString = FileUtils.readFileToString(new File(publicPath), Charset.defaultCharset());
        // 创建key的工厂
        KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
        // 创建公钥key的规则
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(Base64.decode(publicKeyString));
        // 返回公钥对象
        return keyFactory.generatePublic(keySpec);
    }
}