学习JAVA中RSA算法实现

package org.java.se.security.rsa;

import java.io.IOException;
import java.security.InvalidKeyException;
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.SignatureException;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;

import org.java.se.security.base64.Base64;
import org.junit.Before;
import org.junit.Test;

/**
 * RSA加密解密和签名的实现
 * @author xianglj
 */
public class RSACodec {

	/**
	 * RSA的签名算法
	 */
	private static final String ALGORITHM_RSA = "RSA";
	/**
	 * 签名算法
	 */
	private static final String ALGORITHM_SIGNATURE = "MD5withRSA";
	
	private static final String RSA_PRIVATE_KEY = "RSAPrivateKey";
	
	private static final String RSA_PUBLIC_KEY = "RSAPublicKey";
	
	/**
	 * 生成私钥和私钥对
	 * @return
	 * @throws NoSuchAlgorithmException 
	 */
	public static Map<String, Key> generateKeyPair() throws NoSuchAlgorithmException {
		KeyPairGenerator generator = KeyPairGenerator.getInstance(ALGORITHM_RSA);
		KeyPair keyPair = generator.generateKeyPair();
		PublicKey pk = keyPair.getPublic();
		PrivateKey prK = keyPair.getPrivate();
		Map<String, Key> keyMap = new HashMap<String, Key>();
		keyMap.put(RSA_PRIVATE_KEY, prK);
		keyMap.put(RSA_PUBLIC_KEY, pk);
		return keyMap;
	}
	
	/**
	 * 签名。运用私钥进行签名
	 * @param data 需要加密的数据
	 * @param secretKey 私钥字符串-base64加密字符串
	 * @return
	 * @throws IOException 
	 * @throws NoSuchAlgorithmException 
	 * @throws InvalidKeySpecException 
	 * @throws InvalidKeyException 
	 * @throws SignatureException 
	 */
	public static String sign(byte[] data, String secretKey) throws IOException, NoSuchAlgorithmException, InvalidKeySpecException, InvalidKeyException, SignatureException {
		byte[] bytes = Base64.decript(secretKey);
		//获取私钥
		PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(bytes);
		KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM_RSA);
		PrivateKey pk = keyFactory.generatePrivate(keySpec);
		//进行签名
		Signature signnature = Signature.getInstance(ALGORITHM_SIGNATURE);
		signnature.initSign(pk);
		signnature.update(data);
		return Base64.encript(signnature.sign());
	}
	
	/**
	 * 验证签名
	 * @return
	 * @throws IOException 
	 * @throws NoSuchAlgorithmException 
	 * @throws InvalidKeySpecException 
	 * @throws InvalidKeyException 
	 * @throws SignatureException 
	 */
	public static boolean verify(byte[] data, String publicKey, String sign) throws IOException, NoSuchAlgorithmException, InvalidKeySpecException, InvalidKeyException, SignatureException {
		//生成公钥
		byte[] bytes = Base64.decript(publicKey);
		//构造X509EncodedKeySpec对象
		X509EncodedKeySpec keySpec = new X509EncodedKeySpec(bytes);
		KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM_RSA);
		PublicKey pk = keyFactory.generatePublic(keySpec);
		
		//验证签名
		Signature signature = Signature.getInstance(ALGORITHM_SIGNATURE);
		signature.initVerify(pk);
		signature.update(data);
		return signature.verify(Base64.decript(sign));
	}
	
	/**
	 * 采用私钥对数据进行加密
	 * 
	 * @param data
	 * @param privateKey
	 * @throws IOException 
	 * @throws NoSuchAlgorithmException 
	 * @throws InvalidKeySpecException 
	 * @throws NoSuchPaddingException 
	 * @throws InvalidKeyException 
	 * @throws BadPaddingException 
	 * @throws IllegalBlockSizeException 
	 */
	public static String encriptByPrivateKey(byte[] data, String privateKey) 
			throws IOException, NoSuchAlgorithmException, InvalidKeySpecException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException {
		//获取privateKey
		byte[] bytes = Base64.decript(privateKey);
		PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(bytes);
		KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM_RSA);
		PrivateKey pk = keyFactory.generatePrivate(keySpec);
		
		//对数据进行加密
		Cipher cipher = Cipher.getInstance(ALGORITHM_RSA);
		cipher.init(Cipher.ENCRYPT_MODE, pk);
		cipher.update(data);
		return Base64.encript(cipher.doFinal());
	}
	
	/**
	 * 通过公钥加密
	 * 
	 * @param data
	 * @param publicKey
	 * @return
	 * @throws IOException
	 * @throws InvalidKeySpecException
	 * @throws NoSuchAlgorithmException
	 * @throws NoSuchPaddingException 
	 * @throws InvalidKeyException 
	 * @throws BadPaddingException 
	 * @throws IllegalBlockSizeException 
	 */
	public static String encriptByPublicKey(byte[] data, String publicKey) throws IOException, InvalidKeySpecException, NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException {
		byte[] bytes = Base64.decript(publicKey);
		X509EncodedKeySpec keySpec = new X509EncodedKeySpec(bytes);
		PublicKey pk = KeyFactory.getInstance(ALGORITHM_RSA).generatePublic(keySpec);
		
		Cipher cipher = Cipher.getInstance(ALGORITHM_RSA);
		cipher.init(Cipher.ENCRYPT_MODE, pk);
		cipher.update(data);
		return Base64.encript(cipher.doFinal());
	}
	
	/**
	 * 使用私钥进行解密。
	 * @param data 采用PublicKey进行加密的字节数组
	 * @param privateKey 私钥的Base64字符串。
	 * @return 采用私钥解密后的byte数组
	 * @throws IOException 
	 * @throws NoSuchAlgorithmException 
	 * @throws InvalidKeySpecException 
	 * @throws NoSuchPaddingException 
	 * @throws InvalidKeyException 
	 * @throws BadPaddingException 
	 * @throws IllegalBlockSizeException 
	 */
	public static byte[] decriptByPrivateKey(byte[] data, String privateKey) throws IOException, InvalidKeySpecException, NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException {
		//获取私钥
		byte[] pkBytes = Base64.decript(privateKey);
		//构造PKCS8EncodedKeySpec对象
		PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(pkBytes);
		PrivateKey pk = KeyFactory.getInstance(ALGORITHM_RSA).generatePrivate(keySpec);
		
		//进行解密
		Cipher cipher = Cipher.getInstance(ALGORITHM_RSA); //构建Cipher对象
		//设置cipher的模式
		cipher.init(Cipher.DECRYPT_MODE, pk);
		//解密数据
		cipher.update(data);
		return cipher.doFinal();
	}
	
	/**
	 * 根据公钥进行解密
	 * 
	 * @param data 经过私钥加密的字节数组
	 * @param publicKey 公钥字符串
	 * @return 解密后的字节数组
	 * @throws IOException 
	 * @throws NoSuchAlgorithmException 
	 * @throws InvalidKeySpecException 
	 * @throws NoSuchPaddingException 
	 * @throws InvalidKeyException 
	 * @throws BadPaddingException 
	 * @throws IllegalBlockSizeException 
	 */
	public static byte[] decriptByPublicKey(byte[] data, String publicKey) throws IOException, InvalidKeySpecException, NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException {
		//获取公钥
		byte[] pkBytes = Base64.decript(publicKey);
		X509EncodedKeySpec keySpec = new X509EncodedKeySpec(pkBytes);
		PublicKey pk = KeyFactory.getInstance(ALGORITHM_RSA).generatePublic(keySpec);
		
		Cipher cipher = Cipher.getInstance(ALGORITHM_RSA);
		cipher.init(Cipher.DECRYPT_MODE, pk);
		cipher.update(data);
		return cipher.doFinal();
	}
	
	/**
	 * 获取公钥字符串
	 */
	public static String getPublicKey() {
		Key publicKey = keyMap.get(RSA_PUBLIC_KEY);
		return Base64.encript(publicKey.getEncoded());
	}
	
	/**
	 * 获取私钥
	 * @return
	 */
	public static String getPrivateKey() {
		Key privateKey = keyMap.get(RSA_PRIVATE_KEY);
		return Base64.encript(privateKey.getEncoded());
	}
	
	private static Map<String, Key> keyMap ;
	
	@Before
	public void setUp() throws NoSuchAlgorithmException {
		keyMap = generateKeyPair();
	}
	
	@Test
	public void testSign() throws InvalidKeyException, NoSuchAlgorithmException, InvalidKeySpecException, SignatureException, IOException {
		String privateKey = getPrivateKey();
		String publicKey = getPublicKey();
		System.out.println("私钥:" + privateKey);
		System.out.println("公钥：" + publicKey);
		
		//需要签名的数据
		String data = "这个数据需要签名";
		String signData = sign(data.getBytes(), privateKey);
		System.out.println("签名的数据为:" + signData);
		//验证签名
		boolean isSuc = verify(data.getBytes(), publicKey, signData);
		System.out.println("签名是否成功:" + isSuc);
	}
	
	/**
	 * 测试使用公钥加密，私钥解密
	 * @throws IOException 
	 * @throws BadPaddingException 
	 * @throws IllegalBlockSizeException 
	 * @throws NoSuchPaddingException 
	 * @throws NoSuchAlgorithmException 
	 * @throws InvalidKeySpecException 
	 * @throws InvalidKeyException 
	 */
	@Test
	public void testCript() throws InvalidKeyException, InvalidKeySpecException, NoSuchAlgorithmException, NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException, IOException {
		String privateKey = getPrivateKey();
		String publicKey = getPublicKey();
		
		//设置需要加密的字符串
		String str = "我将要被公钥加密，私钥解密哦。。。。";
		System.out.println("明文为:\r\n" + str);
		
		//利用公钥加密
		String encriptStr = encriptByPublicKey(str.getBytes(), publicKey);
		System.out.println("采用公钥加密后的密文为:\r\n" + encriptStr);
		
		//采用私钥解密
		byte[] pkBytes = decriptByPrivateKey(Base64.decript(encriptStr), privateKey);
		String decriptStr = new String(pkBytes);
		System.out.println("采用公钥解密后的明文为:\r\n" + decriptStr);
		
		//比较
		System.out.println("明文和密文是否一致:\r\n" + (str.equals(decriptStr)));
	}
	
	/**
	 * 测试采用私钥加密，公钥解密
	 * 
	 * @throws InvalidKeyException
	 * @throws NoSuchAlgorithmException
	 * @throws InvalidKeySpecException
	 * @throws NoSuchPaddingException
	 * @throws IllegalBlockSizeException
	 * @throws BadPaddingException
	 * @throws IOException
	 */
	@Test
	public void encriptTest() throws InvalidKeyException, NoSuchAlgorithmException, InvalidKeySpecException, NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException, IOException {
		String privateKey = getPrivateKey();
		String publicKey = getPublicKey();
		
		//设置需要加密的字符串
		String str = "我将要被私钥加密，用公钥解密....";
		System.out.println("明文：" + str);
		
		//利用私钥加密
		String ecriptStr = encriptByPrivateKey(str.getBytes(), privateKey);
		System.out.println("利用公钥加密后的密文为:" + ecriptStr);
		
		//利用公钥解密
		byte[] pkBytes = decriptByPublicKey(Base64.decript(ecriptStr), publicKey);
		String decriptStr = new String(pkBytes);
		System.out.println("解密后的明文为:" + decriptStr);
		
		//比较
		System.out.println("是否一致:" + (str.equals(decriptStr)));
	}
}

RSA为非对称加密算法，主要实现步骤：

    1. 生成密钥对。私钥和公钥。公钥可以对外公布，或者发布于客户端使用。

    2. RSA的加密和解密，都需要密钥的参与。如果采用PublicKey进行加密，则需要对应的 PrivateKey 进行解密。如果采用PrivateKey加密，则需要PublicKey进行解密。因此为了数据的安全性，需要妥善保管密钥