RSA加密解密算法代码实现【scala&java】

1. 什么是RSA加密算法？

1.1 对称加密和非对称加密

• 对称加密：对称加密指的就是加密和解密使用同一个秘钥，所以叫做对称加密。对称加密只有一个秘钥，作为私钥。常见的对称加密算法：DES，AES，3DES等等。
• 非对称加密：非对称加密指的是：加密和解密使用不同的秘钥，一把作为公开的公钥，另一把作为私钥。公钥加密的信息，只有私钥才能解密。私钥加密的信息，只有公钥才能解密。常见的非对称加密算法：RSA，ECC

1.2 RSA加密算法

RSA加密算法是一种非对称加密算法，是通过两个密钥（公钥-私钥）来实现对数据的加密和解密的。公钥用于加密，私钥用于解密。

2. scala实现RSA加密

Object Rsa{
	   /**
     * 公钥加密
     * 传入参数为需要加密的字符串origStr，返回结果为加密后的字符串和私钥的元组（encodeStr,privateKeyStr）
     */
	def rsaEncryPtion(origStr:String):(String,String)={
		//生成公钥和私钥
		val keyPairGenerator = KeyPairGenerator.getInstance("RSA")
		keyPairGenerator.initialize(1024, new SecureRandom())
		val keyPair = keyPairGenerator.generateKeyPair()
		val privateKey = keyPair.getPrivate
		val privateKeyStr = new String(Base64.encode(privateKey.getEncoded))
		val publicKey = keyPair.getPublic
		val publicKeyStr = new String(Base64.encode(publicKey.getEncoded))
		//进行加密处理
		val encoded = Base64.decode(publicKeyStr)
     	val rsaPublicKey = KeyFactory.getInstance("RSA").generatePublic(new X509EncodedKeySpec(encoded))
		val cipher = Cipher.getInstance("RSA")
		cipher.init(Cipher.ENCRYPT_MODE, rsaPublicKey)
		val encodeStr = Base64.encode(cipher.doFinal(origStr.getBytes("UTF-8")))
		(encodeStr,privateKeyStr)
	}
	   /**
     * 私钥解密
     * 传入参数为加密过后的字符串encodeStr、私钥privateStr，返回结果为解密后的数据
     */
	def rsaDecryPtion(encodeStr:String,privateKeyStr:String):String={
		val bytes = Base64.decode(encodeStr)
		val decoded = Base64.decode(privateKey)
		val rsaPrivateKey = KeyFactory.getInstance("RSA").generatePrivate(new PKCS8EncodedKeySpec(decoded))
		val cipher = Cipher.getInstance("RSA")
		cipher.init(Cipher.DECRYPT_MODE, rsaPrivateKey)
		val codeStr = new String(cipher.doFinal(bytes))
		codeStr
	}

	def main(args: Array[String]) {
		//待加密的数据
		val origData = "RSA from korry24"
		//加密
		val origDecry = rsaEncryPtion(origData)
		//加密后的数据
		val encodeStr = origDecry._1
		//私钥
		val privateKeyStr = origDecry._2
		//解密
		val codeStr = rsaDecryPtion(encodeStr,privateKeyStr)
 	}

}

3. java实现RSA加密

public class RSACrypt {

    private static Map<Integer, String> keyMap = new HashMap<Integer, String>();
    
    /**
     * 初始化生成公钥和私钥
     *  
     */
    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);
    }
}