Java RSA 工具类

package cn.fg.util;

import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;

import javax.crypto.Cipher;

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

public class RSAUtil {
	
	/**
	 * 获取base64编码后的公私钥串
	 * @return pri=私钥串，pub=公钥串
	 */
	public static Map<String, String> getKeyPair2Base64String(){
		try {
			KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");
			keyPairGen.initialize(1024);
			
			/**
			 * keyPair生成的秘钥格式为x509和pkcs8，密钥存储采用的是der（二进制）
			 */
			KeyPair keyPair = keyPairGen.generateKeyPair(); 
			
			Map<String, String> map = new HashMap<String, String>();
			map.put("pri", Base64.encodeBase64String(keyPair.getPrivate().getEncoded()));
			map.put("pub", Base64.encodeBase64String(keyPair.getPublic().getEncoded()));
			return map;
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}
	
	
	/**
	 * 公钥加密
	 * @param data 待加密数据
	 * @param base64StringPublicKey base64编码后的公钥串
	 * @return
	 */
	public static String encrypt(String data,String base64StringPublicKey) {
		try {
			KeyFactory keyFactory = KeyFactory.getInstance("RSA");
			X509EncodedKeySpec x509 = new X509EncodedKeySpec(Base64.decodeBase64(base64StringPublicKey));
        	PublicKey publicKey = keyFactory.generatePublic(x509);
			Cipher cipher = Cipher.getInstance("RSA"); //等同于RSA/ECB/PKCS1Padding
            cipher.init(Cipher.ENCRYPT_MODE, publicKey);
            return Base64.encodeBase64String(cipher.doFinal(data.getBytes("utf-8")));
        } catch (Exception e) {
        	e.printStackTrace();
            return "";
        }
	}
	
	/**
	 * 私钥解密
	 * @param base64StringData base64编码后的待解密数据串
	 * @param base64StringPrivateKey base64编码后的私钥串
	 * @return
	 */
	public static String decrypt(String base64StringData,String base64StringPrivateKey) {
		try {
			KeyFactory keyFactory = KeyFactory.getInstance("RSA");
			PKCS8EncodedKeySpec pkcs8 = new PKCS8EncodedKeySpec(Base64.decodeBase64(base64StringPrivateKey));
        	PrivateKey privateKey = keyFactory.generatePrivate(pkcs8);
			Cipher cipher = Cipher.getInstance("RSA");
            cipher.init(Cipher.DECRYPT_MODE, privateKey);
            return new String(cipher.doFinal(Base64.decodeBase64(base64StringData)),"utf-8");
        } catch (Exception e) {
        	e.printStackTrace();
            return "";
        }
	}

	//加解密其他方式演示
	public static void encryptAndDecryptOhterDemo() {
		try {
			KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");
			keyPairGen.initialize(1024);
			KeyPair keyPair = keyPairGen.generateKeyPair(); 
			Cipher cipher = Cipher.getInstance("RSA"); 
			
			String data = "待加密的原始数据";
	        cipher.init(Cipher.ENCRYPT_MODE, keyPair.getPublic()); //公钥加密
	        String encryptedString = Base64.encodeBase64String(cipher.doFinal(data.getBytes("utf-8")));
	        System.out.println(encryptedString); //输出加密后的数据
	        
	        cipher.init(Cipher.DECRYPT_MODE, keyPair.getPrivate());  //私钥解密
	        String decryptedString = new String(cipher.doFinal(Base64.decodeBase64(encryptedString)),"utf-8");
	        System.out.println(decryptedString);  //输出解密后的数据
		} catch (Exception e) {
			
        }
	}

	/**
	 * 转换为pkcs8-pem格式的公钥，pem采用base64存数密钥数据
	 * @param base64PublicKey 本类生成的base64编码后的公钥
	 * @return
	 */
	public static String formatPublicKey2Pem(String base64PublicKey) {
		StringBuilder sb = new StringBuilder();
		sb.append("-----BEGIN PUBLIC KEY-----").append("\n");
        //base64PublicKey.replace("_", "/").replace("-", "+").replace("\n", "");
        int count = (base64PublicKey.length() - 1) / 64 + 1;
        for (int i = 0; i < count; i++) {
            if (i + 1 == count) {
            	sb.append(base64PublicKey.substring(i * 64)).append("\n");
            } else {
            	sb.append(base64PublicKey.substring(i * 64, i * 64 + 64)).append("\n");
            }
        }
        sb.append("-----END PUBLIC KEY-----").append("\n");
        return sb.toString();
    }

	//签名
	public static String sign(String data,PrivateKey privateKey) {
		try {
			//获取签名对象，参数为签名算法（md5、sha1、sha256等等，但是这里需要传入java的标准名称才行：MD5withRSA、SHA1withRSA、SHA256withRSA）
			Signature signature = Signature.getInstance("SHA1withRSA");  
			signature.initSign(privateKey);  //初始化签名
			signature.update(data.getBytes("utf-8")); //传入待签名数据
			byte[] signed = signature.sign(); //签名
			return Base64.encodeBase64String(signed);
		} catch (Exception e) {
			return null;
		}
	}
	
	//验签
	public static boolean verify(String data, String algorithm, PublicKey publicKey, String signaturedData) {
		try {
	        Signature signature = Signature.getInstance("SHA1withRSA");
	        signature.initVerify(publicKey); //初始化校验
	        signature.update(data.getBytes("utf-8")); //传入待验证的数据
	        return signature.verify(Base64.decodeBase64(signaturedData)); //校验数据
		} catch (Exception e) {
			return false;
		}
    }
	
	public static void main(String[] args) {
		Map<String, String> map = RSAUtil.getKeyPair2Base64String();
		String encrypted = RSAUtil.encrypt("hello", map.get("pub"));
		String decrypted = RSAUtil.decrypt(encrypted, map.get("pri"));
		System.out.println("加密后：" + encrypted);
		System.out.println("解密后：" + decrypted);
	}
	
}