RSA生成密钥、签名、验签

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import java.security.*;
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.Base64;
import java.util.HashMap;
import java.util.Map;

/**
 * RSA工具类
 * 生成公钥、私钥、签名、验签
 */
public class RSATools {

    // 键算法
    private static final String KEY_ALGORITHM = "RSA";

    // 签名算法
    private static final String SIGNATURE_ALGORITHM = "MD5withRSA";

    // 默认长度
    private static final int DEFAULT_KEY_SIZE = 1024;

    /**
     * 生成秘钥对，默认长度1024
     */
    public static Map<String, String> generateKeyPair() {
        return generateKeyPair(DEFAULT_KEY_SIZE);
    }

    /**
     * 生成秘钥对，可指定长度[512-2048]范围
     *
     * @param keySize
     * @return
     */
    public static Map<String, String> generateKeyPair(int keySize) {

        try {

            // 创建密钥对生成器
            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(KEY_ALGORITHM);
            // 初始化密钥对生成器
            keyPairGenerator.initialize(keySize, new SecureRandom());

            // 生成密钥对
            KeyPair keyPair = keyPairGenerator.generateKeyPair();

            // 获取私钥
            RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
            String privateKeyString = Base64.getEncoder().encodeToString(privateKey.getEncoded());

            // 获得公钥
            RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
            String publicKeyString = Base64.getEncoder().encodeToString(publicKey.getEncoded());

            Map<String, String> keyPairMap = new HashMap<>();
            keyPairMap.put("privateKey", privateKeyString);
            keyPairMap.put("publicKey", publicKeyString);
			
			return keyPairMap;

        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }

        return null;

    }

    /**
     * 加密
     *
     * @param key
     * @param data
     * @return
     */
    public static byte[] encrypt(Key key, byte[] data) {

        try {

            Cipher cipher = Cipher.getInstance(KEY_ALGORITHM);
            cipher.init(Cipher.ENCRYPT_MODE, key);

            return cipher.doFinal(data);

        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (NoSuchPaddingException e) {
            e.printStackTrace();
        } catch (BadPaddingException e) {
            e.printStackTrace();
        } catch (IllegalBlockSizeException e) {
            e.printStackTrace();
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        }

        return null;

    }

    /**
     * 解密
     *
     * @param key
     * @param data
     * @return
     */
    public static byte[] decrypt(Key key, byte[] data) {

        try {

            Cipher cipher = Cipher.getInstance(KEY_ALGORITHM);
            cipher.init(Cipher.DECRYPT_MODE, key);

            return cipher.doFinal(data);

        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (NoSuchPaddingException e) {
            e.printStackTrace();
        } catch (BadPaddingException e) {
            e.printStackTrace();
        } catch (IllegalBlockSizeException e) {
            e.printStackTrace();
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        }

        return null;

    }

    /**
     * 签名
     *
     * @param key
     * @param data
     * @return
     */
    public static String sign(String key, byte[] data) {

        try {

            PrivateKey privateKey = getPrivateKey(key);

            Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
            signature.initSign(privateKey);
            signature.update(data);

            return  Base64.getEncoder().encodeToString(signature.sign());

        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (SignatureException e) {
            e.printStackTrace();
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        }

        return null;

    }

    /**
     * 验签
     *
     * @param key
     * @param sign
     * @param data
     * @return
     * @throws Exception
     */
    public static boolean verify(String key, String sign, byte[] data) {

        try {

            PublicKey publicKey = getPublicKey(key);

            Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
            signature.initVerify(publicKey);
            signature.update(data);

            return signature.verify(Base64.getDecoder().decode(sign));

        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (SignatureException e) {
            e.printStackTrace();
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        }

        return false;

    }

    /**
     * 获取私钥
     *
     * @param key
     * @return
     */
    private static PrivateKey getPrivateKey(String key) {

        byte[] keyBytes = Base64.getDecoder().decode(key);

        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);

        try {
            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
            PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
            return privateKey;
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (InvalidKeySpecException e) {
            e.printStackTrace();
        }

        return null;

    }

    /**
     * 获取公钥
     *
     * @param key
     * @return
     */
    private static PublicKey getPublicKey(String key) {

        byte[] keyBytes = Base64.getDecoder().decode(key);

        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);

        try {
            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
            PublicKey publicKey = keyFactory.generatePublic(keySpec);
            return publicKey;
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (InvalidKeySpecException e) {
            e.printStackTrace();
        }

        return null;

    }

}