RSA公鑰加密-私鑰解密/私鑰加密-公鑰解密

package com.tebon.ams.util;

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

import javax.crypto.Cipher;
import java.security.*;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;

/**
 * @description: ${description}
 * @author: dfz
 * @create: 2019-05-16
 **/
public class RSA {
 private static Logger logger = Logger.getLogger(RSA.class);

 private static final String KEY_ALGORITHM = "RSA";
 private static final int RSA_KEY_SIZE = 1024;
 public final static String UTF8 = "utf-8";
 private static Map<Integer, String> keyMap = new HashMap<Integer, String>();

 public static String formatString(String source) {
 if (source == null) {
 return null;
 }
 return source.replaceAll("\\r", "").replaceAll("\\n", "");
 }

 //用於封裝隨機產生的公鑰與私鑰
 public static void main(String[] args) throws Exception {
 //生成公鑰和私鑰
 genKeyPair();
 //加密字符串
 String message = "df723820";
 System.out.println("隨機生成的公鑰爲:" + keyMap.get(0));
 System.out.println("隨機生成的私鑰爲:" + keyMap.get(1));

 //公鑰加密、私鑰解密
 String messageEn = encrypt(message, keyMap.get(0));
 System.out.println(message + "公鑰加密後的字符串爲:" + messageEn);
 String messageDe = decrypt(messageEn, keyMap.get(1));
 System.out.println("私鑰解密字符串爲:" + messageDe);

 //私鑰加密、公鑰解密
 String enc = encryptByPrivateKey(message, keyMap.get(1));
 System.out.println(message + "私鑰加密後的字符串爲:" + enc);
 String de = decryptByPublicKey(enc, keyMap.get(0));
 System.out.println("公鑰解密後的字符串:" + de);

 }

 /**
 * 隨機生成密鑰對
 *
 * @throws NoSuchAlgorithmException
 */
 public static void genKeyPair() throws NoSuchAlgorithmException {
 //KeyPairGenerator類用於生成公鑰和私鑰對，基於RSA算法生成對象
 KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
 //初始化密鑰對生成器，密鑰大小爲96-1024位
 keyPairGen.initialize(RSA_KEY_SIZE, new SecureRandom());
 // 生成一個密鑰對，保存在keyPair中
 KeyPair keyPair = keyPairGen.generateKeyPair();
 RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
 // 獲得私鑰
 RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
 // 獲得公鑰
 String publicKeyString = new String(Base64.encodeBase64(publicKey.getEncoded()));
 // 獲得私鑰字符串
 String privateKeyString = new String(Base64.encodeBase64((privateKey.getEncoded())));
 // 將公鑰和私鑰保存到Map
 keyMap.put(0, publicKeyString);// 0表示公鑰
 keyMap.put(1, privateKeyString);// 1表示私鑰
 }

 /**
 * RSA公鑰加密
 *
 * @param str 加密字符串
 * @param publicKey 公鑰
 * @return 密文
 * @throws Exception 加密過程當中的異常信息
 */

 public static String encrypt(String str, String publicKey) throws Exception {
 publicKey = formatString(publicKey);
 //base64編碼的公鑰
 byte[] decoded = Base64.decodeBase64(publicKey);
 RSAPublicKey pubKey = (RSAPublicKey) KeyFactory.getInstance(KEY_ALGORITHM).generatePublic(new X509EncodedKeySpec(decoded));
 //RSA加密
 Cipher cipher = Cipher.getInstance(KEY_ALGORITHM);
 cipher.init(Cipher.ENCRYPT_MODE, pubKey);
 String outStr = Base64.encodeBase64String(cipher.doFinal(str.getBytes(UTF8)));
 return outStr;
 }

 /**
 * RSA私鑰解密
 *
 * @param str 加密字符串
 * @param privateKey 私鑰
 * @return 銘文
 * @throws Exception 解密過程當中的異常信息
 */
 public static String decrypt(String str, String privateKey) throws Exception {
 privateKey = formatString(privateKey);
 //64位解碼加密後的字符串
 byte[] inputByte = Base64.decodeBase64(str.getBytes(UTF8));
 // base64編碼的私鑰
 byte[] decoded = Base64.decodeBase64(privateKey);
 RSAPrivateKey priKey = (RSAPrivateKey) KeyFactory.getInstance(KEY_ALGORITHM).generatePrivate(new PKCS8EncodedKeySpec(decoded));
 // RSA解密
 Cipher cipher = Cipher.getInstance(KEY_ALGORITHM);
 cipher.init(Cipher.DECRYPT_MODE, priKey);
 String outStr = new String(cipher.doFinal(inputByte));
 return outStr;
 }

 /**
 * 私鑰加密
 *
 * @param data 加密數據
 * @param privateKey 私鑰
 * @return
 */
 public static String encryptByPrivateKey(String data, String privateKey) {
 try {
 privateKey = formatString(privateKey);
 byte[] kb = Base64.decodeBase64(privateKey.getBytes(UTF8));
 PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(kb);
 KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
 PrivateKey key = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
 Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
 cipher.init(Cipher.ENCRYPT_MODE, key);
 byte[] b = data.getBytes(UTF8);
 byte[] encrypt = cipher.doFinal(b);
 return Base64.encodeBase64String(encrypt);
 } catch (Exception e) {
 logger.error("Failed to encryptByPrivateKey data.", e);
 throw new RuntimeException();
 }
 }

 /**
 * 公鑰解密
 *
 * @param data 解密數據
 * @param publicKey 公鑰
 * @return
 */
 public static String decryptByPublicKey(String data, String publicKey) {
 try {
 publicKey = formatString(publicKey);
 byte[] kb = Base64.decodeBase64(publicKey.getBytes(UTF8));
 X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(kb);
 KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
 PublicKey key = keyFactory.generatePublic(x509EncodedKeySpec);
 Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
 //Cipher cipher = Cipher.getInstance(RSA_PADDING_KEY);
 cipher.init(Cipher.DECRYPT_MODE, key);
 byte[] b = data.getBytes(UTF8);
 byte[] decrypt = cipher.doFinal(Base64.decodeBase64(b));
 return new String(decrypt, UTF8);
 } catch (Exception e) {
 logger.error("Failed to decryptByPublicKey data.", e);
 throw new RuntimeException();
 } }}