RSA非对称加密解密方法

package com.hcmony.date;

import javax.crypto.Cipher;
import java.io.UnsupportedEncodingException;
import java.security.*;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * RSA工具类
 */
public class RsaHelper {


    private final static String prikey = "MIICdwIBADANBgkqhkiG9w0BAQEFAASCAmEwggJdAgEAAoGBAJIBjm8+UUJNiMcaYKZB9dSx4oMC3BBdbNIi" +
            "8Iv1SH3wvi7x3lYFSEZJJu5BK9q5z7Ualw6taA2AqclF2zRUELe4YOaKspfcoqbrCLtY+Ohkbpz/u7hThs7H0WiqM5/j+YQoS30cVx1rmf1" +
            "+KFYgo1CzFOK/OE2mnZb7BFYxFxqFAgMBAAECgYBgUGaFO7ae5ka0ENJw2lIwXKfvhJNmuDpw5FuJ9+Q6L/VFQohIdnOW6eqkgJlNUAWUkl" +
            "XTeNCLF7To8QwJGOttRGyeTJxzweZivqjwZeHCk+cy9ApqJmjTtmD42Hnxz6qLSiE96KfjnGdT/0bklxfkNdtAjAUMCWu7xA64Hh+AAQJBA" +
            "OBd1DXTGD2jpeIpxc0efKw9CBroV0RCWpB1EsOfpMUHytq/vIhAsQj6xQDQz8trN8WVnl7mozxZYzBrEtpTFwECQQCml2zyjycjrFv1qdAh" +
            "EC+F688YYeLCmfLMvseiD6gRUpUtcrEr1YugJCUfYq6EO7m5AwTasimqjVCAETt+ayeFAkBOI19Mf3/pt5yF71Zb4Uo6EedIt7Hsq88ukBd" +
            "A2dBgbh5PoIbgTOda4TrK1e4IQgbiYQEOu/QNiHPq4N9n+ZgBAkEAhkvMKD3+72MjPweGISFLLkrKyH0gsIAqm6Owi5TTiCNq3xh2ez/LL2" +
            "3z/zkuNqtvLRah8yttK3CAVL2PmHoJgQJBAKoH18KRqlfAbvuj0XWMkUvlUG/9tB9ck/Eg0dGgylK0qNObK9ApQPvIj0zTJp6b7lv6DAKZQ" +
            "xsQ1Mds871Cwoo=";
    private final static String pubkey = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCSAY5vPlFCTYjHGmCmQfXUseKDAtwQXWzSIvCL9Uh98L4u" +
            "8d5WBUhGSSbuQSvauc+1GpcOrWgNgKnJRds0VBC3uGDmirKX3KKm6wi7WPjoZG6c/7u4U4bOx9FoqjOf4/mEKEt9HFcda5n9fihWIKNQsxT" +
            "ivzhNpp2W+wRWMRcahQIDAQAB";


    /**
     * 加密算法RSA
     */
    private static final String KEY_ALGORITHM = "RSA";
    /**
     * 获取公钥的key
     */
    private static final String PUBLIC_KEY = "RSAPublicKey";

    /**
     * 获取私钥的key
     */
    private static final String PRIVATE_KEY = "RSAPrivateKey";

    /**
     * 默认配置的是UTF-8
     */
    private static final String encoding_UTF8 = "UTF-8";

    /**
     *
     */
    public static final String encoding_GBK = "GBK";

    /**
     * 加密时每块字节数
     */
    private static final int EncryptBlockSize = 117;
    /**
     * 解密时每块字节数
     */
    private static final int DecryptBlockSize = 128;

    /**
     * 生成RSA密钥对(默认密钥长度为1024)
     *
     * @return r
     */
    public static KeyPair generateRSAKeyPair() {
        return generateRSAKeyPair(1024);
    }

    /**
     * 生成RSA密钥对
     *
     * @param keyLength 密钥长度，范围：512～2048
     * @return r
     */
    public static KeyPair generateRSAKeyPair(int keyLength) {
        try {
            KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA");
            kpg.initialize(keyLength);
            return kpg.genKeyPair();
        } catch (NoSuchAlgorithmException e) {
            return null;
        }
    }

    /**
     * <p>
     * 生成密钥对(公钥和私钥)
     * </p>
     *
     * @return r
     * @throws Exception e
     */
    public static Map<String, Object> genKeyPair() throws Exception {
        KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
        keyPairGen.initialize(1024);
        KeyPair keyPair = keyPairGen.generateKeyPair();
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
        Map<String, Object> keyMap = new HashMap<String, Object>(2);
        keyMap.put(PUBLIC_KEY, publicKey);
        keyMap.put(PRIVATE_KEY, privateKey);
        return keyMap;
    }



    /**
     * <p>
     * 获取私钥
     * </p>
     *
     * @param keyMap 密钥对
     * @return r
     */
    public static String getPrivateKey(Map<String, Object> keyMap) {
        Key key = (Key) keyMap.get(PRIVATE_KEY);
        return Base64Helper.encode(key.getEncoded());
    }

    /**
     * <p>
     * 获取私钥
     * </p>
     *
     * @param keyMap 密钥对
     * @return RSAPrivateKey
     * @throws Exception ex
     */
    public static RSAPrivateKey getPrivateKeyed(Map<String, Object> keyMap) {
        RSAPrivateKey key = (RSAPrivateKey) keyMap.get(PRIVATE_KEY);
        return key;
    }

    /**
     * <p>
     * 获取公钥
     * </p>
     *
     * @param keyMap 密钥对
     * @return RSAPrivateKey
     * @throws Exception ex
     */
    public static RSAPublicKey getPublicKeyed(Map<String, Object> keyMap) {
        RSAPublicKey key = (RSAPublicKey) keyMap.get(PUBLIC_KEY);
        return key;
    }

    /**
     * <p>
     * 获取公钥
     * </p>
     *
     * @param keyMap 密钥对
     * @return e
     * @throws Exception w
     */
    public static String getPublicKey(Map<String, Object> keyMap) {
        Key key = (Key) keyMap.get(PUBLIC_KEY);
        return Base64Helper.encode(key.getEncoded());
    }


    /**
     * 用公钥加密，支持任意长度字符串，按每块117个字符压缩。
     *
     * @param data   d
     * @param pubKey p
     * @return 错误返回null
     */
    public static byte[] encryptData(byte[] data, PublicKey pubKey) {
        try {
            Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
            cipher.init(Cipher.ENCRYPT_MODE, pubKey);
            int blocks = data.length / EncryptBlockSize;
            if (data.length % EncryptBlockSize != 0) {
                blocks++;
            }
            List<byte[]> results = new ArrayList<byte[]>();
            int totalResultBytes = 0;
            for (int idx = 0; idx < blocks; idx++) {
                // 加密一块117个字节
                int offset = idx * EncryptBlockSize;
                int len = Math.min(data.length - offset, EncryptBlockSize);
                byte[] partResult = cipher.doFinal(data, offset, len);
                totalResultBytes += partResult.length;
                results.add(partResult);
            }

            // 组装返回字节串
            byte[] result = new byte[totalResultBytes];
            int idx = 0;
            for (byte[] temp : results) {
                System.arraycopy(temp, 0, result, idx, temp.length);
                idx += temp.length;
            }
            results.clear();
            return result;

        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 用私钥解密
     *
     * @param encryptedData e
     * @param priKey        p
     * @return 错误返回null
     */
    public static byte[] decryptData(byte[] encryptedData, PrivateKey priKey) {
        try {
            Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
            cipher.init(Cipher.DECRYPT_MODE, priKey);
            int blocks = encryptedData.length / DecryptBlockSize;
            if (encryptedData.length % DecryptBlockSize != 0) {
                blocks++;
            }
            List<byte[]> results = new ArrayList<byte[]>();
            int totalResultBytes = 0;
            for (int idx = 0; idx < blocks; idx++) {
                // 解密一块128个字节
                int offset = idx * DecryptBlockSize;
                int len = Math.min(encryptedData.length - offset, DecryptBlockSize);
                byte[] partResult = cipher.doFinal(encryptedData, offset, len);
                totalResultBytes += partResult.length;
                results.add(partResult);
            }

            // 组装解码字节串
            byte[] result = new byte[totalResultBytes];
            int idx = 0;
            for (byte[] temp : results) {
                System.arraycopy(temp, 0, result, idx, temp.length);
                idx += temp.length;
            }
            results.clear();
            return result;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 根据指定私钥对数据进行签名(默认签名算法为"SHA1withRSA")
     *
     * @param data   要签名的数据
     * @param priKey 私钥
     * @return 错误返回null
     */
    public static byte[] signData(String data, PrivateKey priKey) {
        try {
            return signData(data.getBytes(encoding_UTF8), priKey, "SHA1withRSA");
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 根据指定私钥和算法对数据进行签名
     *
     * @param data      要签名的数据
     * @param priKey    私钥
     * @param algorithm 签名算法
     * @return 错误返回null
     */
    public static byte[] signData(byte[] data, PrivateKey priKey, String algorithm) {
        try {
            Signature signature = Signature.getInstance(algorithm);
            signature.initSign(priKey);
            signature.update(data);
            return signature.sign();
        } catch (Exception ex) {
            ex.printStackTrace();
            return null;
        }
    }

    /**
     * 用指定的公钥进行签名验证(默认签名算法为"SHA1withRSA")
     *
     * @param data   数据
     * @param sign   签名结果
     * @param pubKey 公钥
     * @return r
     */
    public static boolean verifySign(byte[] data, byte[] sign, PublicKey pubKey) {
        return verifySign(data, sign, pubKey, "SHA1withRSA");
    }

    /**
     * 用指定的公钥进行签名验证
     *
     * @param data      数据
     * @param sign      签名结果
     * @param pubKey    公钥
     * @param algorithm 签名算法
     * @return b
     */

    public static boolean verifySign(byte[] data, byte[] sign, PublicKey pubKey, String algorithm) {
        try {
            Signature signature = Signature.getInstance(algorithm);
            signature.initVerify(pubKey);
            signature.update(data);
            return signature.verify(sign);
        } catch (Exception ex) {
            return false;
        }
    }


    public static void main(String[] args)throws Exception {
        byte[] ss = signData("11",getPrivateKey(Base64Helper.decode(prikey)));
        System.out.println(verifySign(StringHelper.convert("11"),ss,getPublicKey(Base64Helper.decode(pubkey))));
        byte[] bytes = encryptData(StringHelper.convert("22"),getPublicKey(Base64Helper.decode(pubkey)));
        System.out.println(StringHelper.convert(decryptData(bytes,getPrivateKey(Base64Helper.decode(prikey)))));

    }

    /**
     * @param source  s
     * @param strHead s
     * @param strTail s
     * @return r
     */
    public static String GetMiddleString(String source, String strHead, String strTail) {
        return GetMiddleString(source, strHead, strTail, false);
    }

    /**
     * @param source          s
     * @param strHead         s
     * @param strTail         s
     * @param KeepHeadAndTail s
     * @return s
     */
    public static String GetMiddleString(String source, String strHead, String strTail, boolean KeepHeadAndTail) {
        try {
            int indexHead, indexTail;

            if (strHead == null || strHead.isEmpty()) {
                indexHead = 0;
            } else {
                indexHead = source.indexOf(strHead);
            }

            if (strTail == null || strTail.isEmpty()) {
                indexTail = source.length();
            } else {
                indexTail = source.indexOf(strTail, indexHead + strHead.length());
            }
            if (indexTail < 0) {
                indexTail = source.length();
            }

            String rtnStr = "";
            if ((indexHead >= 0) && (indexTail >= 0)) {
                if (KeepHeadAndTail) {
                    rtnStr = source.substring(indexHead, indexTail + strTail.length());
                } else {
                    rtnStr = source.substring(indexHead + strHead.length(), indexTail);
                }
            }
            return rtnStr;
        } catch (Exception ex) {
            return "";
        }
    }

    /**
     * 通过公钥byte[]将公钥还原，适用于RSA算法
     * @param keyBytes keys
     * @return pu
     * @throws NoSuchAlgorithmException no
     * @throws InvalidKeySpecException  in
     * @since 1.0
     */
    public static PublicKey getPublicKey(byte[] keyBytes) throws NoSuchAlgorithmException, InvalidKeySpecException {
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        PublicKey publicKey = keyFactory.generatePublic(keySpec);
        return publicKey;
    }

    /**
     *
     * @param keyBytes key
     * @return p
     * @throws NoSuchAlgorithmException n
     * @throws InvalidKeySpecException  i
     * @since 1.0
     */
    public static PrivateKey getPrivateKey(byte[] keyBytes) throws NoSuchAlgorithmException, InvalidKeySpecException {
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
        return privateKey;
    }




}