Java非对称加密算法RSA

程序员文章站 2022-07-04 14:42:11

...

流程分析：

甲方构建密钥对儿，将公钥公布给乙方，将私钥保留。
甲方使用私钥加密数据，然后用私钥对加密后的数据签名，发送给乙方签名以及加密后的数据；乙方使用公钥、签名来验证待解密数据是否有效，如果有效使用公钥对数据解密。
乙方使用公钥加密数据，向甲方发送经过加密后的数据；甲方获得加密数据，通过私钥解密。

package cn.tzz.java.crypto;

import java.io.IOException;
import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
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 RSACryptUtil {

	public static final String KEY_ALGORITHM = "RSA";
	public static final String SIGNATURE_ALGORITHM = "MD5withRSA";
	
	private static final String PUBLIC_KEY = "RSAPublicKey";
	private static final String PRIVATE_KEY = "RSAPrivateKey";
	
	
	public static String encryptBASE64(byte[] key) {  
		return (new BASE64Encoder()).encodeBuffer(key);  
	}
	
	public static byte[] decryptBASE64(String key) throws IOException {  
		return new BASE64Decoder().decodeBuffer(key);
	}
	
	/**初始化密钥*/
	public static Map<String, Object> initKey() {
		KeyPairGenerator keyPairGen;
		Map<String, Object> keyMap = new HashMap<String, Object>(2);
		try {
			keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
			keyPairGen.initialize(1024);
			KeyPair keyPair = keyPairGen.generateKeyPair();
			RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();// 公钥
			RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();// 私钥
			keyMap.put(PUBLIC_KEY, publicKey);
			keyMap.put(PRIVATE_KEY, privateKey);
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		}
		return keyMap;
	}
	
	/**获取私钥*/
	public static String getPrivateKey(Map<String, Object> keyMap){
		Key key = (Key) keyMap.get(PRIVATE_KEY);
		return encryptBASE64(key.getEncoded());
	}
	
	/**获取公钥*/
	public static String getPublicKey(Map<String, Object> keyMap){
		Key key = (Key) keyMap.get(PUBLIC_KEY);
		return encryptBASE64(key.getEncoded());
	}
	
	/**用公钥解密*/
	public static byte[] decryptByPublicKey(byte[] data, String key) throws Exception {
		byte[] keyBytes = decryptBASE64(key);// 对密钥解密
		// 取得公钥
		X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
		Key publicKey = keyFactory.generatePublic(x509KeySpec);
		// 对数据解密
		Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
		cipher.init(Cipher.DECRYPT_MODE, publicKey);
		return cipher.doFinal(data);
	}
	
	/**用私钥解密*/
	public static byte[] decryptByPrivateKey(byte[] data, String key) throws Exception {
		byte[] keyBytes = decryptBASE64(key);// 对密钥解密
		// 取得私钥
		PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
		Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
		// 对数据解密
		Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
		cipher.init(Cipher.DECRYPT_MODE, privateKey);
		return cipher.doFinal(data);
	}
	
	/**用公钥加密*/
	public static byte[] encryptByPublicKey(byte[] data, String key) throws Exception {
		byte[] keyBytes = decryptBASE64(key);// 对公钥解密
		// 取得公钥
		X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
		Key publicKey = keyFactory.generatePublic(x509KeySpec);
		// 对数据加密
		Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
		cipher.init(Cipher.ENCRYPT_MODE, publicKey);
		return cipher.doFinal(data);
	}
	
	/**用私钥加密*/
	public static byte[] encryptByPrivateKey(byte[] data, String key) throws Exception {
		byte[] keyBytes = decryptBASE64(key);// 对密钥解密
		// 取得私钥
		PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
		Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
		// 对数据加密
		Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
		cipher.init(Cipher.ENCRYPT_MODE, privateKey);
		return cipher.doFinal(data);
	}
	
	/**
	 * 用私钥对信息生成数字签名
	 * @param data 加密数据
	 * @param privateKey 私钥
	 */
	public static String sign(byte[] data, String privateKey) throws Exception {
		byte[] keyBytes = decryptBASE64(privateKey);// 解密由base64编码的私钥
		// 构造PKCS8EncodedKeySpec对象
		PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
		// KEY_ALGORITHM 指定的加密算法
		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
		// 取私钥匙对象
		PrivateKey priKey = keyFactory.generatePrivate(pkcs8KeySpec);
		// 用私钥对信息生成数字签名
		Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
		signature.initSign(priKey);
		signature.update(data);
		return encryptBASE64(signature.sign());
	}
	
	/**
	 * 校验数字签名
	 * @param data 加密数据
	 * @param publicKey 公钥
	 * @param sign 数字签名
	 * 
	 * @return 校验成功返回true 失败返回false
	 * 
	 */
	public static boolean verify(byte[] data, String publicKey, String sign) throws Exception {
		byte[] keyBytes = decryptBASE64(publicKey);// 解密由base64编码的公钥
		
		// 构造X509EncodedKeySpec对象
		X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
		// KEY_ALGORITHM 指定的加密算法
		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
		// 取公钥匙对象
		PublicKey pubKey = keyFactory.generatePublic(keySpec);
		Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
		signature.initVerify(pubKey);
		signature.update(data);
		// 验证签名是否正常
		return signature.verify(decryptBASE64(sign));
	}
	
}

测试类：

package cn.tzz.java.crypto;

import java.util.Map;

import org.junit.Test;

public class RSACryptUtilTest {

	private static String publicKey;
	private static String privateKey;
	
	static {
		Map<String, Object> keyMap = RSACryptUtil.initKey();
		publicKey = RSACryptUtil.getPublicKey(keyMap);
		privateKey = RSACryptUtil.getPrivateKey(keyMap);
		System.out.println("公钥: \n\r" + publicKey);
		System.out.println("私钥： \n\r" + privateKey);
	}
	
	@Test
	public void test(){
		try {
			System.out.println("公钥加密---私钥解密");
			String date = "123456";
			byte[] encodedData = RSACryptUtil.encryptByPublicKey(date.getBytes(), publicKey);
			String encodedStr = RSACryptUtil.encryptBASE64(encodedData);
			byte[] decodedData = RSACryptUtil.decryptByPrivateKey(RSACryptUtil.decryptBASE64(encodedStr), privateKey);
			String outputStr = new String(decodedData);
			System.out.println("加密前: " + date + "\n\r" + "加密后: " + encodedStr + "\n\r" + "解密后: " + outputStr);
		} catch (Exception e) {
			e.printStackTrace();
		}
		
	}
	
	@Test
	public void testSign() throws Exception {
		try {
			System.out.println("私钥加密---公钥解密");
			String inputStr = "123456";
			byte[] data = inputStr.getBytes();
			
			byte[] encodedData = RSACryptUtil.encryptByPrivateKey(data, privateKey);
			
			byte[] decodedData = RSACryptUtil.decryptByPublicKey(encodedData, publicKey);
			
			String outputStr = new String(decodedData);
			System.out.println("加密前: " + inputStr + "\n\r" + "解密后: " + outputStr);
			
			System.out.println("私钥签名——公钥验证签名");
			// 产生签名
			String sign = RSACryptUtil.sign(encodedData, privateKey);
			System.out.println("签名:\r" + sign);
			// 验证签名
			boolean status = RSACryptUtil.verify(encodedData, publicKey, sign);
			System.out.println("状态:\r" + status);
		
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

相关标签： RSA 非对称加密算法

上一篇： RSA 工具类

下一篇：黄瓜鸡蛋减肥餐轻松做瘦美人

Java非对称加密算法RSA

RSA非对称私钥加密

Java中4大基本加密算法解析

Java实现的对称加密算法AES定义与用法详解

Java实现RSA算法的方法详解

使用jwt和rsa非对称加密无状态登录

利用JAVA实现DES加密算法

Linux下OpenSSL的DSA与RSA非对称加密解析

RSA详解（Java实现）

ThinkPHP实现的rsa非对称加密类示例

android Java 中使用RSA加密爬坑记录

Java非对称加密算法RSA

RSA非对称 私钥加密

Java中4大基本加密算法解析

Java实现的对称加密算法AES定义与用法详解

Java实现RSA算法的方法详解

使用jwt和rsa非对称加密无状态登录

利用JAVA实现DES加密算法

Linux下OpenSSL的DSA与RSA非对称加密解析

RSA详解（Java实现）

ThinkPHP实现的rsa非对称加密类示例

android Java 中使用RSA加密爬坑记录

RSA非对称私钥加密