RSA加密&解密【Java&Scala】

一.简介

　　RSA加密算法是一种非对称加密算法。在公开密钥加密和电子商业中RSA被广泛使用。

　　RSA公开密钥密码体制。所谓公开密钥密码体制就是使用不同的加密密钥与解密密钥，是一种“由已知加密密钥推导出解密密钥在计算上是不可行的”密码体制。

　　在公开密钥密码体制中，加密密钥（即公开密钥）PK是公开信息，而解密密钥（即秘密密钥）SK是需要保密的。加密算法E和解密算法D也都是公开的。虽然解密密钥SK是由公开密钥PK决定的，由于无法计算出大数n的欧拉函数phi(N)，所以不能根据PK计算出SK。

　　RSA算法是第一个能同时用于加密和数字签名的算法，也易于理解和操作。RSA是被研究得最广泛的公钥算法，从提出到现今的三十多年里，经历了各种攻击的考验，逐渐为人们接受，截止2017年被普遍认为是最优秀的公钥方案之一。　

二.代码实现【Java版】

package cn.ai;

import java.io.UnsupportedEncodingException;
import java.security.InvalidKeyException;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;

import org.apache.commons.codec.binary.Base64;

public class RSACrypt {

    private static Map<Integer, String> keyMap = new HashMap<Integer, String>();
    
    /**
     * 初始化生成公钥和私钥
     * @throws NoSuchAlgorithmException 
     */
    public static void init() throws NoSuchAlgorithmException{
        /**
         * KeyPairGenerator用于生成公钥和私钥对，基于RSA算法生成对象
         */
        KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");
        /**
         * 初始化秘钥对生成器，秘钥大小为1024位
         */
        keyPairGen.initialize(1024, new SecureRandom());
        /**
         * 生成秘钥
         */
        KeyPair keyPair = keyPairGen.generateKeyPair();
        /**
         * 获取私钥
         */
        RSAPrivateKey privateKey = (RSAPrivateKey)keyPair.getPrivate();
        String privateKeyStr = new String(Base64.encodeBase64(privateKey.getEncoded()));
        /**    
         * 获取公钥
         */
        RSAPublicKey publicKey = (RSAPublicKey)keyPair.getPublic();
        String publicKeyStr = new String(Base64.encodeBase64(publicKey.getEncoded()));
        
        /**
         * 保存公钥，私钥
         */
        keyMap.put(0, publicKeyStr); // 公钥
        keyMap.put(1, privateKeyStr);// 私钥
    }
    
    /**
     * 公钥加密
     * @throws NoSuchAlgorithmException 
     * @throws InvalidKeySpecException 
     * @throws Exception 
     */
    public static String rsaEncrypt(String content, String publicKey) throws InvalidKeySpecException, NoSuchAlgorithmException, Exception{
        //base64编码的公钥
        byte[] encoded = Base64.decodeBase64(publicKey);
        RSAPublicKey rsaPublicKey = (RSAPublicKey)KeyFactory.getInstance("RSA").generatePublic(new X509EncodedKeySpec(encoded));
        // RSA加密
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.ENCRYPT_MODE, rsaPublicKey);
        
        String outPublicKey = Base64.encodeBase64String(cipher.doFinal(content.getBytes("UTF-8")));
        
        return outPublicKey;
    }
    
    /**
     * 私钥解密
     * @throws UnsupportedEncodingException 
     * @throws NoSuchAlgorithmException 
     * @throws InvalidKeySpecException 
     * @throws NoSuchPaddingException 
     * @throws InvalidKeyException 
     * @throws BadPaddingException 
     * @throws IllegalBlockSizeException 
     * @throws Exception
     */
    public static String rsaDecrypt(String content, String privateKey) throws UnsupportedEncodingException, InvalidKeySpecException, NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException{
        //base64位解码加密后的字符串
        byte[] inputByte = Base64.decodeBase64(content.getBytes("UTF-8"));
        //base64编码的私钥
        byte[] decoded = Base64.decodeBase64(privateKey);
        RSAPrivateKey rsaPrivateKey = (RSAPrivateKey)KeyFactory.getInstance("RSA").generatePrivate(new PKCS8EncodedKeySpec(decoded));
        //RSA解密
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.DECRYPT_MODE, rsaPrivateKey);
        String outPrivateKey = new String(cipher.doFinal(inputByte));
        return outPrivateKey;
    }
    
    public static void main(String[] args) throws Exception {
        /**
         * 初始化生成公钥，私钥
         */
        init();
        /**
         * 加密数据
         */
        String message = "abc123";
        System.out.println("随机生成的公钥为：" + keyMap.get(0));
        System.out.println("随机生成的私钥为：" + keyMap.get(1));

        System.out.println("加密前的数据：" + message);
        String messageEncrypt = rsaEncrypt(message, keyMap.get(0));
        System.out.println("加密后的数据：" + messageEncrypt);
        
        //String mid = "MIIc" + keyMap.get(1).substring(4, keyMap.get(1).length());
        //System.out.println("随机生成的私钥为：" + mid);
        String messageDecrypt = rsaDecrypt(messageEncrypt, keyMap.get(1));
        System.out.println("解密后的数据：" + messageDecrypt);
    }

}

三.结果【Java版】

1 随机生成的公钥为：MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCzveY+Gdrm4gY2IGT+M1yESXHPLSS7Nq/iex4h2oI3x0kSvYOoepQSPUhZvnUJEsrnYHKI9CZPJXNchqQFdR2Zy70GX/58yA700PVpk278z32aZ4OFkqhrmtULRiwF/ILpjucr7dIrgOU+hFTKHHc0fqhtHVWZVYcf1ZyKP8fQBwIDAQAB
2 随机生成的私钥为：MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBALO95j4Z2ubiBjYgZP4zXIRJcc8tJLs2r+J7HiHagjfHSRK9g6h6lBI9SFm+dQkSyudgcoj0Jk8lc1yGpAV1HZnLvQZf/nzIDvTQ9WmTbvzPfZpng4WSqGua1QtGLAX8gumO5yvt0iuA5T6EVMocdzR+qG0dVZlVhx/VnIo/x9AHAgMBAAECgYAV9yoRAsXem1aY/MJ60joHLJaM8/5eJqO98L/Q8UwilucWNDTHvRslU3npBb51umczeXTlybh4yaHcd9PJmvNf6LI0LsCAWEqW6Y4/1kX2ro8w/a5uLLZMECa9q0xkn0+QWMMrcHxzUVhlott5lDx9ejiW+a3KpNscQLSxgZSeAQJBAN2N45wUFSvcGFZAOwHL6YpCIrECokdhFFp+eABPYJb+rDFfFyiiK8THk/osD2l0Tqtdl+mPJEAbXU1aK0VdnQECQQDPr9OwC0rpvttzq6TiEJ4S1Dz3kZwS2NkrukbgqWkGpC7HggBjYYyrujoEpEnPvqnm6oTWCDqh+YRWC6RMp4UHAkAJCwiWT0+J6cLoilieOyd+KDLoTLY4+aJuCyl0wcisgRqgLURxuSTWNFs649+BK2kmn3xa4SfWogdN5/dKLocBAkACeZjvNyM8Z97boQcE/qezl73mQWD3xIfKAp1Hnh03TAuWqxDwHkB752s7lO2gQShrLQ5KMqzoMz4FfHwHwdNPAkEAtNG3NONm0f4McwEYyxXkrlLWisf67xkTo6rLfxnf7f+xk8W6u6kf339AZlfOUv5I1BZKfka3hUxaXlpsYmQ0Xg==
3 加密前的数据：abc123
4 加密后的数据：s4P8ihNvDHdqB3libM2lj8eC37TQK/UBrUIKM4If42oMYiCVo/4q07FPLfDYCBMEa9sbdDSFA1mcXiWRvwIH+658Nu+dLSe1SQfuwI+7q0KbP0lQeCh3SkBvTqAt0BmEnpDvSUzn1FH/W8Wlqet9IBsTU7mZioXZ9jCSTvKvU8w=
5 解密后的数据：abc123

四.代码实现【Scala版】

package big.data.analyse.encryption

import java.security.spec.{PKCS8EncodedKeySpec, X509EncodedKeySpec}
import java.security.{KeyFactory, SecureRandom, KeyPairGenerator}
import javax.crypto.Cipher

import org.apache.commons.codec.binary.Base64

/**
  * Created by zhen on 2019/6/15.
  */
object RSA {
  var keyMap : Map[Int, String] = Map()

  /**
    * 初始化公钥，私钥
    */
  def init(): Unit ={
    val keyPairGenerator = KeyPairGenerator.getInstance("RSA")
    keyPairGenerator.initialize(1024, new SecureRandom())
    val keyPair = keyPairGenerator.generateKeyPair()
    val privateKey = keyPair.getPrivate
    val privateKeyStr = new String(Base64.encodeBase64(privateKey.getEncoded))

    val publicKey = keyPair.getPublic
    val publicKeyStr = new String(Base64.encodeBase64(publicKey.getEncoded))

    keyMap += (0 -> publicKeyStr) // 0表示公钥
    keyMap += (1 -> privateKeyStr) // 1表示私钥
  }

  /**
    * 公钥加密
    */
  def rsaEncrypt(content : String, publicKey : String): String ={
    val encoded = Base64.decodeBase64(publicKey)
    val rsaPublicKey = KeyFactory.getInstance("RSA").generatePublic(new X509EncodedKeySpec(encoded))

    val cipher = Cipher.getInstance("RSA")
    cipher.init(Cipher.ENCRYPT_MODE, rsaPublicKey)

    val enContent = Base64.encodeBase64String(cipher.doFinal(content.getBytes("UTF-8")))

    return enContent
  }

  /**
    * 私钥解密
    */
  def rsaDecrypt(content : String, privateKey : String): String ={
    val bytes = Base64.decodeBase64(content.getBytes("UTF-8"))
    val decoded = Base64.decodeBase64(privateKey)
    val rsaPrivateKey = KeyFactory.getInstance("RSA").generatePrivate(new PKCS8EncodedKeySpec(decoded))

    val cipher = Cipher.getInstance("RSA")
    cipher.init(Cipher.DECRYPT_MODE, rsaPrivateKey)

    val deContent = new String(cipher.doFinal(bytes))

    return deContent
  }

  /**
    * 测试
    * @param args
    */
  def main(args: Array[String]) {

    /**
      * 初始化加密算法
      */
    init()
    println("公钥：" +keyMap.get(0).get+ "\n私钥：" + keyMap.get(1).get)

    /**
      * 加密内容
      */
    val content = "abc123"
    println("加密前的数据：" + content)

    /**
      * 加密
      */
    val enContent = rsaEncrypt(content, keyMap.get(0).get)
    println("加密后的数据：" + enContent)

    /**
      * 解密
      */
    val deContent = rsaDecrypt(enContent, keyMap.get(1).get)
    println("解密后的数据：" + deContent)
  }
}

 五.结果【Scala版】

公钥：MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCpWv6go/JB6/fgkFobB8UNG9yGEPEdJnRxy26YISXb2ACRvC1BZ4bKECdnVk5EMwEyIxtfYLbvf0PjVq1CYAimYd6D97teWSQM0ZsdYYzUeSz+KJABugt4A4LNitnfmn1jOToSdjlXZIlrzKQtNxXi4fEFHqg5CMUgrbU40amrcQIDAQAB
私钥：MIICeAIBADANBgkqhkiG9w0BAQEFAASCAmIwggJeAgEAAoGBAKla/qCj8kHr9+CQWhsHxQ0b3IYQ8R0mdHHLbpghJdvYAJG8LUFnhsoQJ2dWTkQzATIjG19gtu9/Q+NWrUJgCKZh3oP3u15ZJAzRmx1hjNR5LP4okAG6C3gDgs2K2d+afWM5OhJ2OVdkiWvMpC03FeLh8QUeqDkIxSCttTjRqatxAgMBAAECgYAOIpgqFET+F5Hi3mmG5AkgZPjs/7EAO9twPAiJDgs45Dh38XrdgKSRbPO8/kkeDBvHcYKxXUMnjjm+WdewOI/AIJfhRD4dSW7vLEhDAD/sWN2gop34uFLIwFI4XESvdlObqFU082HqsiC6qP4b2/W5S5JDSx2kQaRLppl1/wX6mQJBANdhmlp2S3aHalKqdViTyLmwqDmQQQDCrdLUs0BCJIJBaRWiN5EbLeCF4EtbCN8Pe6KtiV1R1ZnAlvm7dVlCldMCQQDJS09ybefxe/CApr6ppK7bwSf2vVOqDO2dBm46oapK6otpSSt1USvah0yGNenu7hoPFFyFe3vlrbV3dQJBFdsrAkEAv67Xxma9ZnHCCGw4H2r3G3vDW+esUlbwiFBQb4HuKBa6xUwnk/bSb532LlqInKyU5gT32Zu5NCsYso1JNPVzjQJBAJNruWKnxW/hAlFmTUq21m0Q+HDHVce7siYHOKFuFubJAZL5SH+iFAj2f//m6k3XSXRzyBLmTeX3I2i6ZA1AsYMCQQCXnuh0VjBTqSrvrEWXlnyiQ1cpQdmAhI6YlnKW3Mcd6jjekCjAG7CXU1N845Ax7btTlF1Ca+vwcaVzm0oF80mQ
加密前的数据：abc123
加密后的数据：jcSjLubNx/1Vk4FEWBwukb8FK3w/QMNZ6UY5lZxLuMxvQ+sl/9cndIh5wNRkzowxmxDQnNcMlUQ5qwIvKnExSVXfBuoRKBH7J+9q7yb1XQR+m+r53djTrNbV15wztHO7KDh4bhlUSbv217OkTdBMb8Exh4aKuih7cUdsD9XQ+60=
解密后的数据：abc123