RSA工具类

package com.foxit.utils;

import java.io.ByteArrayOutputStream;
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.Signature;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
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.Cipher;

import com.foxit.constant.Constants;

import jcifs.util.Base64;

public class RSAUtils {
	public final String CHARSET = "UTF-8";
    /**
     * 加密算法RSA
     */
    public static final String RSA_ALGORITHM = "RSA";
    
    /**
     * 签名算法
     */
    public static final String SIGNATURE_ALGORITHM = "SHA1withRSA";
    
    /**
     * 初始化KeyPairGenerator对象,密钥长度
     */
    public static final int KEY_SIZE = 1024;
    
    /**
     * 生成公私钥
     * @param keySize
     * @return
     */
	public Map<String, String> createKeys(){
        //为RSA算法创建一个KeyPairGenerator对象
        KeyPairGenerator kpg;
        try{
            kpg = KeyPairGenerator.getInstance(RSA_ALGORITHM);
        }catch(NoSuchAlgorithmException e){
            throw new IllegalArgumentException("No such algorithm-->[" + RSA_ALGORITHM + "]");
        }

        //初始化KeyPairGenerator对象,密钥长度
        kpg.initialize(KEY_SIZE);
        //生成密匙对
        KeyPair keyPair = kpg.generateKeyPair();
        //得到公钥
        Key publicKey = keyPair.getPublic();
        String publicKeyStr = Base64.encode(publicKey.getEncoded());
        //得到私钥
        Key privateKey = keyPair.getPrivate();
        String privateKeyStr = Base64.encode(privateKey.getEncoded());
        Map<String, String> keyPairMap = new HashMap<String, String>();
        keyPairMap.put("publicKey", publicKeyStr);
        keyPairMap.put("privateKey", privateKeyStr);

        return keyPairMap;
    }
	
	/**
     * 得到公钥
     * @param publicKey 密钥字符串（经过base64编码）
     * @throws Exception
     */
    public RSAPublicKey getPublicKey(String publicKey) throws NoSuchAlgorithmException, InvalidKeySpecException {
        //通过X509编码的Key指令获得公钥对象
        KeyFactory keyFactory = KeyFactory.getInstance(RSA_ALGORITHM);
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(Base64.decode(publicKey));
        RSAPublicKey key = (RSAPublicKey) keyFactory.generatePublic(x509KeySpec);
        return key;
    }

    /**
     * 得到私钥
     * @param privateKey 密钥字符串（经过base64编码）
     * @throws Exception
     */
    public RSAPrivateKey getPrivateKey(String privateKey) throws NoSuchAlgorithmException, InvalidKeySpecException {
        //通过PKCS#8编码的Key指令获得私钥对象
        KeyFactory keyFactory = KeyFactory.getInstance(RSA_ALGORITHM);
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(Base64.decode(privateKey));
        RSAPrivateKey key = (RSAPrivateKey) keyFactory.generatePrivate(pkcs8KeySpec);
        return key;
    }
    
    /**
     * 签名（经过Base64编码）
     * @param priKey
     * @param src
     * @return
     */
    public String sign(String priKey, String src)  
    {  
        try  
        {  
            PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(Base64.decode(priKey));  
            KeyFactory fac = KeyFactory.getInstance("RSA");  
            RSAPrivateKey privateKey = (RSAPrivateKey) fac.generatePrivate(keySpec);  
            Signature sigEng = Signature.getInstance(SIGNATURE_ALGORITHM);  
            sigEng.initSign(privateKey);  
            sigEng.update(src.getBytes());  
            byte[] signature = sigEng.sign();  
            return Base64.encode(signature);  
        }  
        catch (Exception e)  
        {  
            e.printStackTrace();  
            return null;  
        }  
    }
	
    /**
     * 验证签名
     * @param pubKey
     * @param sign
     * @param src
     * @return
     */
    public boolean verify(String pubKey, String sign, String src)  
    {  
        try  
        {  
            X509EncodedKeySpec keySpec = new X509EncodedKeySpec(Base64.decode(pubKey));  
            KeyFactory fac = KeyFactory.getInstance("RSA");  
            RSAPublicKey rsaPubKey = (RSAPublicKey) fac.generatePublic(keySpec);  
            Signature sigEng = Signature.getInstance(SIGNATURE_ALGORITHM);
            sigEng.initVerify(rsaPubKey);  
            sigEng.update(src.getBytes());  
            return sigEng.verify(Base64.decode(sign));  
        }  
        catch (Exception e)  
        {  
            e.printStackTrace();  
            return false;  
        }  
    }
    
	/**
     * 公钥加密
     * @param data
     * @param publicKey
     * @return
     */
    public String publicEncrypt(String data, String publicKey){
        try{
        	//通过X509编码的Key指令获得公钥对象
            KeyFactory keyFactory = KeyFactory.getInstance(RSA_ALGORITHM);
            X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(Base64.decode(publicKey));
            RSAPublicKey key = (RSAPublicKey) keyFactory.generatePublic(x509KeySpec);
            Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
            cipher.init(Cipher.ENCRYPT_MODE, key);
            //return Base64.encode(rsaSplitCodec(cipher, Cipher.ENCRYPT_MODE, data.getBytes(CHARSET), key.getModulus().bitLength()));
            return Base64.encode(rsaSplitCodec(cipher, Cipher.ENCRYPT_MODE, data.getBytes(), key.getModulus().bitLength()));
        }catch(Exception e){
            throw new RuntimeException("加密字符串[" + data + "]时遇到异常", e);
        }
    }

    /**
     * 私钥解密
     * @param data
     * @param privateKey
     * @return
     */
    public String privateDecrypt(String data, String privateKey){
        try{
        	//通过PKCS#8编码的Key指令获得私钥对象
            KeyFactory keyFactory = KeyFactory.getInstance(RSA_ALGORITHM);
            PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(Base64.decode(privateKey));
            RSAPrivateKey key = (RSAPrivateKey) keyFactory.generatePrivate(pkcs8KeySpec);
            Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
            cipher.init(Cipher.DECRYPT_MODE, key);
            //return new String(rsaSplitCodec(cipher, Cipher.DECRYPT_MODE, Base64.decode(data), key.getModulus().bitLength()), CHARSET);
            return new String(rsaSplitCodec(cipher, Cipher.DECRYPT_MODE, Base64.decode(data), key.getModulus().bitLength()));
        }catch(Exception e){
            throw new RuntimeException("解密字符串[" + data + "]时遇到异常", e);
        }
    }

    /**
     * 私钥加密
     * @param data
     * @param privateKey
     * @return
     */
    public String privateEncrypt(String data, String privateKey){
        try{
        	//通过PKCS#8编码的Key指令获得私钥对象
            KeyFactory keyFactory = KeyFactory.getInstance(RSA_ALGORITHM);
            PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(Base64.decode(privateKey));
            RSAPrivateKey key = (RSAPrivateKey) keyFactory.generatePrivate(pkcs8KeySpec);
            Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
            cipher.init(Cipher.ENCRYPT_MODE, key);
            //return Base64.encode(rsaSplitCodec(cipher, Cipher.ENCRYPT_MODE, data.getBytes(CHARSET), key.getModulus().bitLength()));
            return Base64.encode(rsaSplitCodec(cipher, Cipher.ENCRYPT_MODE, data.getBytes(), key.getModulus().bitLength()));
        }catch(Exception e){
            throw new RuntimeException("加密字符串[" + data + "]时遇到异常", e);
        }
    }

    /**
     * 公钥解密
     * @param data
     * @param publicKey
     * @return
     */
    public String publicDecrypt(String data, String publicKey){
        try{
        	//通过X509编码的Key指令获得公钥对象
            KeyFactory keyFactory = KeyFactory.getInstance(RSA_ALGORITHM);
            X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(Base64.decode(publicKey));
            RSAPublicKey key = (RSAPublicKey) keyFactory.generatePublic(x509KeySpec);
            Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
            cipher.init(Cipher.DECRYPT_MODE, key);
            //return new String(rsaSplitCodec(cipher, Cipher.DECRYPT_MODE, Base64.decode(data), key.getModulus().bitLength()), CHARSET);
            return new String(rsaSplitCodec(cipher, Cipher.DECRYPT_MODE, Base64.decode(data), key.getModulus().bitLength()));
        }catch(Exception e){
            throw new RuntimeException("解密字符串[" + data + "]时遇到异常", e);
        }
    }
    
    private byte[] rsaSplitCodec(Cipher cipher, int opmode, byte[] datas, int keySize){
        int maxBlock = 0;
        if(opmode == Cipher.DECRYPT_MODE){
            maxBlock = keySize / 8;
        }else{
            maxBlock = keySize / 8 - 11;
        }
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] buff;
        int i = 0;
        byte[] resultDatas = null;
        try{
            while(datas.length > offSet){
                if(datas.length-offSet > maxBlock){
                    buff = cipher.doFinal(datas, offSet, maxBlock);
                }else{
                    buff = cipher.doFinal(datas, offSet, datas.length-offSet);
                }
                out.write(buff, 0, buff.length);
                i++;
                offSet = i * maxBlock;
                resultDatas = out.toByteArray();
            }
        }catch(Exception e){
            throw new RuntimeException("加解密阀值为["+maxBlock+"]的数据时发生异常", e);
        }finally{
        	if (out != null) {
    			try {
					out.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
        	}
        }
        return resultDatas;
    }
    
    public static String PUBLIC_KEY = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCDL3yQu+Pl1Ybz2iZ9bK7RYsXN/lzeXJAw3jdce34AYsSg0TR7gYl9gv4I7sJR18tyhSd2NmzIsZuHcVbgKoFv2aP6uK8OanVZ9Bo1yXN7KKtB242D8/vfb9zB9My968ma5+A/TKu33IDRsD5FMCINFklALnnL3YRakTZeCONfTQIDAQAB";
    public static String PRIVATE_KEY = "MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBAIMvfJC74+XVhvPaJn1srtFixc3+XN5ckDDeN1x7fgBixKDRNHuBiX2C/gjuwlHXy3KFJ3Y2bMixm4dxVuAqgW/Zo/q4rw5qdVn0GjXJc3soq0HbjYPz+99v3MH0zL3ryZrn4D9Mq7fcgNGwPkUwIg0WSUAuecvdhFqRNl4I419NAgMBAAECgYBQItfzCfPDWFah66cLgzKfUbkHhtRwORcT4wrqgb2MusjmfCWVNKIqe7R2/HLT0ADFqjVa7xAw4N3jNQce1JhQPItXgSTREBUMY6UPg2p4MDV9iYbOpOuJonH2wZtMc+NP3apRXX9wgYfXy4SbXA0DqTT4pvCjh602dKKuD2MneQJBAMY7LFRSF7uW0fut66UHBXdXWUHpr1hchCsCosNU6H48kzyDUAXMUt3LeH48kLwaqlbUi+Aic3ubdvQt8AXV7jcCQQCpanFi6nlYB8XnWmCfXZ007hIEhDo7aKDXiHss5utxd0Ox/9lLI5lSZfHtXWW4Gl3ca1FogyUfIge0jsMmEvybAkEArApDCNNOgaH9j/57mvgjCFYowwm7AmcY1fMtq3UPai/MYSJd2wpfiNrEMlsCCh7iYwWId/euXkKo1Hbh706htQJANtV49acmt1NsvsEF3Q8Tvvn/Yu7ZWjk3Ngu6soHbWtJbWtWQoz1WdtEASO+d6MS/9IPXyZgI/9an380FZOFoWQJAZSW6ZA6E67XhXVUBpo2YWCPPMHghKOEJwEy1y8NnpA575Rdx3UXR2gJeLVdS/3vyta8B2hAjJrCyBfOeI4Q0Xw==";
	public static void main(String[] args) {
		RSAUtils rsa = new RSAUtils();
		String data = "FRS-1EJEPGRPSEExpress,Export,Print,ElecStamp,VerifyDocument,FileAttachment,Annotation,PageFormat,RStamp,FreeText,MultiMedia,DigitalSignature,AdvEditor,Encryption,AdvExtension,Organizer,Creator,OCR,Scanner,Outline,AdvSearch,DocProcessing5flpWindows2018-06-192018-03-21Ver:2,Keyver:1,Edition:Standard,Lang:zh_cn,md5:N3yehqyzlot8kNBewSr4DS/ZNG58jt6cNYFhtKg4bnM=";
		String sign = "yZCr/WxMULjlFCiRU7vCMkNvN8GlVKpw331PbX7CGrU7js/4ipsAuENpXlP7ol2F4AuIZR/TtJ9IRoXArq4or/7ZUCzlQOkY+nR5JQ5YnkmqHUJg7iQoA0bFxotwyKBeiXGV4HlOf+ChdkS9pdB75D8aGK/oU1exASs4JuBHRBI=";
		/*String pubkey = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDPz5inMgFYh93zhGgPnjWXemGh1jzqHtKcL1L7BLe9WBY2iE41QaA4n4BjB3hO7Vec1FhCiclBmt+r/qtp5e6RQyxinTnPmUwXZTUZEhLjOSrE1WRmlsuW/IR/nGEbvnXm/AKehHy2/+LvUmSztvaODQ9v8BaUEDxgyAMTiNtY0QIDAQAB";
		boolean f = rsa.verify(pubkey, sign, data);
		System.out.println("签名校验：" + f);*/
		String s = rsa.sign(Constants.SIGN_RSA_PRIVATE, data);
		System.out.println(s);
		boolean f = rsa.verify(Constants.SIGN_RSA_PUBLIC, s, data);
		System.out.println("签名校验：" + f);
		
		/*boolean flagSign = rsa.verify(Constants.SIGN_RSA_PUBLIC_NETWORK, sign, data);
		System.out.println("签名校验：" + flagSign);*/
	}
}