Java实现RSA算法加解密

- 日理万妓 2022-04-23 05:18 435阅读 0赞

**RSA加解密工具类**

import java.io.ByteArrayOutputStream;
 import java.security.Key;
 import java.security.KeyFactory;
 import java.security.KeyPair;
 import java.security.KeyPairGenerator;
 import java.security.PrivateKey;
 import java.security.PublicKey;
 import java.security.Signature;
 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;
 
 import javax.crypto.Cipher;
 
 import sun.misc.BASE64Decoder;
 import sun.misc.BASE64Encoder;
 
 public class RSAUtils {
 
 /**
 * 加密算法RSA
 */
 public static final String KEY_ALGORITHM = "RSA";
 
 /**
 * 签名算法
 */
 public static final String SIGNATURE_ALGORITHM = "MD5withRSA";
 
 /**
 * 获取公钥的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;
 
 /**
 * 
 * 生成密钥对(公钥和私钥)
 * 
 * 
 * @return
 * @throws Exception
 */
 public static Map<String, Object> genKeyPair() throws Exception {
 KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
 keyPairGen.initialize(1024);
 KeyPair keyPair = keyPairGen.generateKeyPair();
 RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
 RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
 Map<String, Object> keyMap = new HashMap<String, Object>(2);
 keyMap.put(PUBLIC_KEY, publicKey);
 keyMap.put(PRIVATE_KEY, privateKey);
 return keyMap;
 }
 
 /**
 * 
 * 用私钥对信息生成数字签名
 * 
 * 
 * @param data 已加密数据
 * @param privateKey 私钥(BASE64编码)
 * 
 * @return
 * @throws Exception
 */
 public static String sign(byte[] data, String privateKey) throws Exception {
 byte[] keyBytes = new BASE64Decoder().decodeBuffer(privateKey);
 PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
 KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
 PrivateKey privateK = keyFactory.generatePrivate(pkcs8KeySpec);
 Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
 signature.initSign(privateK);
 signature.update(data);
 return new BASE64Encoder().encode(signature.sign());
 }
 
 /**
 * 
 * 校验数字签名
 * 
 * 
 * @param data 已加密数据
 * @param publicKey 公钥(BASE64编码)
 * @param sign 数字签名
 * 
 * @return
 * @throws Exception
 * 
 */
 public static boolean verify(byte[] data, String publicKey, String sign)
 throws Exception {
 byte[] keyBytes = new BASE64Decoder().decodeBuffer(publicKey);
 X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
 KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
 PublicKey publicK = keyFactory.generatePublic(keySpec);
 Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
 signature.initVerify(publicK);
 signature.update(data);
 return signature.verify(new BASE64Decoder().decodeBuffer(sign));
 }
 
 /**
 * 
 * 私钥解密
 * 
 * 
 * @param encryptedData 已加密数据
 * @param privateKey 私钥(BASE64编码)
 * @return
 * @throws Exception
 */
 public static byte[] decryptByPrivateKey(byte[] encryptedData, String privateKey)
 throws Exception {
 byte[] keyBytes = new BASE64Decoder().decodeBuffer(privateKey);
 PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
 KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
 Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
 Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
 cipher.init(Cipher.DECRYPT_MODE, privateK);
 int inputLen = encryptedData.length;
 ByteArrayOutputStream out = new ByteArrayOutputStream();
 int offSet = 0;
 byte[] cache;
 int i = 0;
 // 对数据分段解密
 while (inputLen - offSet > 0) {
 if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
 cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
 } else {
 cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
 }
 out.write(cache, 0, cache.length);
 i++;
 offSet = i * MAX_DECRYPT_BLOCK;
 }
 byte[] decryptedData = out.toByteArray();
 out.close();
 return decryptedData;
 }
 
 /**
 * 
 * 公钥解密
 * 
 * 
 * @param encryptedData 已加密数据
 * @param publicKey 公钥(BASE64编码)
 * @return
 * @throws Exception
 */
 public static byte[] decryptByPublicKey(byte[] encryptedData, String publicKey)
 throws Exception {
 byte[] keyBytes = new BASE64Decoder().decodeBuffer(publicKey);
 X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
 KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
 Key publicK = keyFactory.generatePublic(x509KeySpec);
 Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
 cipher.init(Cipher.DECRYPT_MODE, publicK);
 int inputLen = encryptedData.length;
 ByteArrayOutputStream out = new ByteArrayOutputStream();
 int offSet = 0;
 byte[] cache;
 int i = 0;
 // 对数据分段解密
 while (inputLen - offSet > 0) {
 if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
 cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
 } else {
 cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
 }
 out.write(cache, 0, cache.length);
 i++;
 offSet = i * MAX_DECRYPT_BLOCK;
 }
 byte[] decryptedData = out.toByteArray();
 out.close();
 return decryptedData;
 }
 
 /**
 * 
 * 公钥加密
 * 
 * 
 * @param data 源数据
 * @param publicKey 公钥(BASE64编码)
 * @return
 * @throws Exception
 */
 public static byte[] encryptByPublicKey(byte[] data, String publicKey)
 throws Exception {
 byte[] keyBytes = new BASE64Decoder().decodeBuffer(publicKey);
 X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
 KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
 Key publicK = keyFactory.generatePublic(x509KeySpec);
 // 对数据加密
 Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
 cipher.init(Cipher.ENCRYPT_MODE, publicK);
 int inputLen = data.length;
 ByteArrayOutputStream out = new ByteArrayOutputStream();
 int offSet = 0;
 byte[] cache;
 int i = 0;
 // 对数据分段加密
 while (inputLen - offSet > 0) {
 if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
 cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
 } else {
 cache = cipher.doFinal(data, offSet, inputLen - offSet);
 }
 out.write(cache, 0, cache.length);
 i++;
 offSet = i * MAX_ENCRYPT_BLOCK;
 }
 byte[] encryptedData = out.toByteArray();
 out.close();
 return encryptedData;
 }
 
 /**
 * 
 * 私钥加密
 * 
 * 
 * @param data 源数据
 * @param privateKey 私钥(BASE64编码)
 * @return
 * @throws Exception
 */
 public static byte[] encryptByPrivateKey(byte[] data, String privateKey)
 throws Exception {
 byte[] keyBytes = new BASE64Decoder().decodeBuffer(privateKey);
 PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
 KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
 Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
 Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
 cipher.init(Cipher.ENCRYPT_MODE, privateK);
 int inputLen = data.length;
 ByteArrayOutputStream out = new ByteArrayOutputStream();
 int offSet = 0;
 byte[] cache;
 int i = 0;
 // 对数据分段加密
 while (inputLen - offSet > 0) {
 if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
 cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
 } else {
 cache = cipher.doFinal(data, offSet, inputLen - offSet);
 }
 out.write(cache, 0, cache.length);
 i++;
 offSet = i * MAX_ENCRYPT_BLOCK;
 }
 byte[] encryptedData = out.toByteArray();
 out.close();
 return encryptedData;
 }
 
 /**
 * 
 * 获取私钥
 * 
 * 
 * @param keyMap 密钥对
 * @return
 * @throws Exception
 */
 public static String getPrivateKey(Map<String, Object> keyMap)
 throws Exception {
 Key key = (Key) keyMap.get(PRIVATE_KEY);
 return new BASE64Encoder().encode(key.getEncoded());
 }
 
 /**
 * 
 * 获取公钥
 * 
 * 
 * @param keyMap 密钥对
 * @return
 * @throws Exception
 */
 public static String getPublicKey(Map<String, Object> keyMap)
 throws Exception {
 Key key = (Key) keyMap.get(PUBLIC_KEY);
 return new BASE64Encoder().encode(key.getEncoded());
 }
 
 }

**测试结果**

import java.util.Map;
 
 public class RSA {
 	
 	/**
 * A和B进行加密通信时,A要给B发送消息,B首先要生成一对密钥。B自己持有私钥,公钥发送给A。A使用B发送的公钥加密内容，B通过自己的私钥解密内容
 * 若B给A发送消息,B首先使用自己的私钥生成签名并发送给A,A使用B发送的公钥验证签名,验证成功使用公钥解密内容
 */
 	public static void main(String[] args) throws Exception {
 		try {
 			//B生成一对密钥
 			Map<String, Object> keyMap = RSAUtils.genKeyPair();
 	 String publicKey = RSAUtils.getPublicKey(keyMap);
 	 String privateKey = RSAUtils.getPrivateKey(keyMap);
 	 
 	 //公钥加密——私钥解密(A给B发送消息)
 			String sourcePuk = "公钥加密——私钥解密";
 	 System.out.println("加密前：\n" + sourcePuk);
 	 //A使用B发送的公钥加密内容
 	 byte[] encodedDataPuk = RSAUtils.encryptByPublicKey(sourcePuk.getBytes(), publicKey);
 	 System.out.println("加密后：\n" + new String(encodedDataPuk));
 	 //B使用自己的私钥解密内容
 	 byte[] decodedDataPuk = RSAUtils.decryptByPrivateKey(encodedDataPuk, privateKey);
 	 String targetPuk = new String(decodedDataPuk);
 	 System.out.println("解密后: \n" + targetPuk);
 	 
 	 //私钥签名——公钥验证签名(B给A发送消息)
 	 String sourcePrk = "私钥签名——公钥验证签名";
 	 System.out.println("\n加密前：\r\n" + sourcePrk);
 	 byte[] encodedDataPrk = RSAUtils.encryptByPrivateKey(sourcePrk.getBytes(), privateKey);
 	 System.out.println("加密后：\r\n" + new String(encodedDataPrk));
 	 //B使用自己的私钥生成签名并发送给A
 	 String sign = RSAUtils.sign(encodedDataPrk, privateKey);
 	 //A使用B发送的公钥验证签名
 	 boolean status = RSAUtils.verify(encodedDataPrk, publicKey, sign);
 	 if(status){
 	 	//验证成功,A使用公钥解密内容
 	 	byte[] decodedDataPrk = RSAUtils.decryptByPublicKey(encodedDataPrk, publicKey);
 		 String targetPrk = new String(decodedDataPrk);
 		 System.out.println("解密后: \r\n" + targetPrk);
 	 }
 } catch (Exception e) {
 e.printStackTrace();
 }
 	}
 }