RSA相助类

package com.cmb.fmserver.passport.util;

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.interfaces.RSAPublicKey;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;

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

import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

@SuppressWarnings("restriction")
public class RSAHelper {
	/**
	 * 得到公钥
	 * @throws IOException 
	 * @throws NoSuchAlgorithmException 
	 * @throws InvalidKeySpecException 
	 */

	public static PublicKey getPublicKey(String key) throws IOException,
			NoSuchAlgorithmException, InvalidKeySpecException {
		byte[] keyBytes;

		keyBytes = (new BASE64Decoder()).decodeBuffer(key);

		X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);

		KeyFactory keyFactory = KeyFactory.getInstance("RSA");

		PublicKey publicKey = keyFactory.generatePublic(keySpec);

		return publicKey;
	}

	public static PrivateKey getPrivateKey(String key) throws IOException,
			NoSuchAlgorithmException, InvalidKeySpecException {
		byte[] keyBytes;
		keyBytes = new BASE64Decoder().decodeBuffer(key);

		PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
		KeyFactory keyFactory = KeyFactory.getInstance("RSA");
		PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
		return privateKey;

	}

	public static String getKeyString(Key key) {
		byte[] keyBytes = key.getEncoded();
		String s = new BASE64Encoder().encode(keyBytes);
		return s;
	}

	public static void main(String[] args) throws IOException,
			NoSuchAlgorithmException, InvalidKeySpecException,
			NoSuchPaddingException, InvalidKeyException,
			IllegalBlockSizeException, BadPaddingException {
		//	System.out.println(RSAHelper.getPublicKey("hello"));

		KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");

		keyPairGen.initialize(1024);

		KeyPair keyPair = keyPairGen.generateKeyPair();

		//System.out.println(keyPair); //null

		//公钥
		PublicKey publicKey = (RSAPublicKey) keyPair.getPublic();

		System.out.println("publicKey:"+publicKey);

		//秘钥
		PrivateKey privateKey = keyPair.getPrivate();

		byte[] publicKeyBytes = publicKey.getEncoded();
		String publicKeyString = (new BASE64Encoder()).encode(publicKeyBytes);
		System.out.println("公钥串："+publicKeyString);
		byte[] privateKeyBytes = privateKey.getEncoded();
		String privateKeyString = (new BASE64Encoder()).encode(privateKeyBytes);
		System.out.println("私钥串："+privateKeyString);
		//加解密类
		Cipher cipher = Cipher.getInstance("RSA");
		String text = "你好世界方　啊方是ｓｄ";
		System.out.println("加密前:"+text);
		//明文
		byte[] plainText = text.getBytes();

		//加密
		cipher.init(Cipher.ENCRYPT_MODE, publicKey);
		byte[] enBytes = cipher.doFinal(plainText);

		//通过秘钥字符串得到秘钥
		publicKey = getPublicKey(publicKeyString);
		privateKey = getPrivateKey(privateKeyString);

		String encodedStr = new String(enBytes, "UTF-8");
		System.out.println("加密密文为:\n" + encodedStr);

		//解密
		cipher.init(Cipher.DECRYPT_MODE, privateKey);

		byte[] deBytes = cipher.doFinal(enBytes);

		//publicKeyString = getKeyString(publicKey);

		//	System.out.println("publicKeyString=\n"+publicKeyString);

		//privateKeyString = getKeyString(privateKey);
		//	System.out.println("privateKeyString=\n"+privateKeyString);

		String s = new String(deBytes);
		System.out.println("解密后："+s);

	}

}