RSA加密工具类

/**
 * RSA加密工具类
 * @author MartinNie
 * @date 2021/9/18 11:47
 */
public class RSAUtil {

	private static final Logger log = LoggerFactory.getLogger(RSAUtil.class);
	private static final String ENCODING = "UTF-8";
	private static final String KEY_ALGORITHM = "RSA";
	/**
	 * 获取公钥的key
	 */
	private static final String PUBLIC_KEY = "RSAPublicKey";

	/**
	 * 获取私钥的key
	 */
	private static final String PRIVATE_KEY = "RSAPrivateKey";

	/**
	 * RSA最大加密明文大小
	 */
	private static final int MAX_ENCRYPT_BLOCK = 117;

	/**
	 * RSA最大解密密文大小
	 */
	private static final int MAX_DECRYPT_BLOCK = 128;

	/**
	 * RSA 位数 如果采用2048 上面最大加密和最大解密则须填写:  245 256
	 */
	private static final int INITIALIZE_LENGTH = 1024;


	/**
	 * 生成密钥对
	 * @return
	 */
	public static Map<String,Object> genKeyPair() {
		try {
			KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
			keyPairGen.initialize(INITIALIZE_LENGTH);
			KeyPair keyPair = keyPairGen.generateKeyPair();
			RSAPublicKey rsaPublicKey = (RSAPublicKey) keyPair.getPublic();
			RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) keyPair.getPrivate();
			Map<String, Object> keyMap = new HashMap<String, Object>(2);
			keyMap.put(PUBLIC_KEY, rsaPublicKey);
			keyMap.put(PRIVATE_KEY, rsaPrivateKey);
			return keyMap;
		} catch (Exception e) {
			log.error("生成密钥对失败！",e);
		}
		return null;
	}

	/**
	 * 获取公钥
	 * @param keyMap
	 * @return
	 */
	public static String getPrivateKey(Map<String,Object> keyMap) {
		Key key = (Key) keyMap.get(PRIVATE_KEY);
		return Base64.encodeBase64String(key.getEncoded());
	}

	/**
	 * 获取私钥
	 * @param keyMap
	 * @return
	 */
	public static String getPublicKey(Map<String,Object> keyMap) {
		Key key = (Key) keyMap.get(PUBLIC_KEY);
		return Base64.encodeBase64String(key.getEncoded());
	}

	/**
	 * 使用公钥加密
	 * @param data
	 * @param publicKey
	 * @return
	 */
	public static byte[] encryptByPublicKey(byte[] data,String publicKey) {
		try {
			byte[] keyBytes = Base64.decodeBase64(publicKey.getBytes(ENCODING));
			X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(keyBytes);
			KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
			PublicKey publicK = keyFactory.generatePublic(x509EncodedKeySpec);
			Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
			cipher.init(Cipher.ENCRYPT_MODE,publicK);
			byte[] encryptData = cipher.doFinal(data);
			return encryptData;
		} catch (Exception e) {
			log.error("使用公钥加密失败！",e);
		}
		return null;
	}

	/**
	 * 使用私钥解密
	 * @param encryptData
	 * @param privateKey
	 * @return
	 */
	public static byte[] decryptByPrivateKey(byte[] encryptData,String privateKey) {
		try {
			byte[] keyBytes = Base64.decodeBase64(privateKey.getBytes(ENCODING));
			PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(keyBytes);
			KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
			PrivateKey privateK = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
			Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
			cipher.init(Cipher.DECRYPT_MODE,privateK);
			byte[] decryptData = cipher.doFinal(encryptData);
			return decryptData;
		} catch (Exception e) {
			log.error("使用私钥解密失败！",e);
		}
		return null;
	}

	/**
	 * 使用私钥加密
	 * @param data
	 * @param privateKey
	 * @return
	 */
	public static byte[] encryptByPrivate(byte[] data,String privateKey) {
		try {
			byte[] keyBytes = Base64.decodeBase64(privateKey.getBytes(ENCODING));
			PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(keyBytes);
			KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
			PrivateKey privateK = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
			Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
			cipher.init(Cipher.ENCRYPT_MODE,privateK);
			byte[] encryptData = cipher.doFinal(data);
			return encryptData;
		} catch (Exception e) {
			log.error("使用私钥加密失败！",e);
		}
		return null;
	}

	/**
	 * 使用公钥解密
	 * @param encryptData
	 * @param publicKey
	 * @return
	 */
	public static byte[] decryptByPublicKey(byte[] encryptData,String publicKey) {
		try {
			byte[] keyBytes = Base64.decodeBase64(publicKey.getBytes(ENCODING));
			X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(keyBytes);
			KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
			PublicKey publicK = keyFactory.generatePublic(x509EncodedKeySpec);
			Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
			cipher.init(Cipher.DECRYPT_MODE,publicK);
			byte[] decryptData = cipher.doFinal(encryptData);
			return decryptData;
		} catch (Exception e) {
			log.error("使用公钥解密失败！",e);
		}
		return null;
	}

	public static void main(String[] args) throws UnsupportedEncodingException {
		String code = "Hello,Word!";
		System.out.println("加密前的数据为" + code);
		byte[] data = code.getBytes();
		Map<String, Object> keyMap = RSAUtil.genKeyPair();
//		Map<String,Object> map = RSAUtil.genKeyPair();
		//获取私钥
		String privateKey = RSAUtil.getPrivateKey(keyMap);
//		String priv = RSAUtil.getPrivateKey(map);
//		System.out.println("priv : " + priv);
		//使用私钥加密
		byte[] encrypt = RSAUtil.encryptByPrivate(data, privateKey);
		String encryptCode = new String(Base64.encodeBase64(encrypt));
		byte[] bytes = Base64.decodeBase64(encryptCode.getBytes(ENCODING));
		byte[] temp = Base64.decodeBase64(encryptCode);
		System.out.println("encrypt :" + encrypt);
		System.out.println("temp :" + temp);
		System.out.println("私钥：" + privateKey );
		System.out.println("加密后的数据为" + encryptCode);

		//获取公钥
		String publicKey = RSAUtil.getPublicKey(keyMap);
//		String publ = RSAUtil.getPublicKey(map);
//		System.out.println("publ:" + publ);
		//使用公钥解密
		byte[] decrypt = RSAUtil.decryptByPublicKey(bytes, publicKey);
		String decryptCode = new String(decrypt);
		System.out.println("公钥：" + publicKey);
		System.out.println("解密后的数据为" + decryptCode);
	}

}