RSA相关代码

package tools.allunion;

import org.springframework.util.Base64Utils;
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.HashMap;
import java.util.Map;

public class RSAUtil {

    public static final String KEY_ALGORITHM = "RSA";
    public static final String PUBLIC_KEY = "publicKey";
    public static final String PRIVATE_KEY = "privateKey";
    public static final int KEY_SIZE = 2048;

    public static final String SIGNATURE_ALGORITHM = "SHA256withRSA";
    public static final String ENCODE_ALGORITHM = "SHA-256";

    /**
     * 生成秘钥对
     *
     * @return
     */
    public static Map<String, byte[]> generateKeyBytes() {
        try {
            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(KEY_ALGORITHM);
            keyPairGenerator.initialize(KEY_SIZE);
            KeyPair keyPair = keyPairGenerator.generateKeyPair();
            RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
            RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
            Map<String, byte[]> keyMap = new HashMap();
            keyMap.put(PUBLIC_KEY, publicKey.getEncoded());
            keyMap.put(PRIVATE_KEY, privateKey.getEncoded());
            return keyMap;
        } catch (NoSuchAlgorithmException ex) {
            ex.printStackTrace();
        }
        return null;
    }

    /**
     * 还原公钥
     *
     * @param keyBytes
     * @return
     */
    public static PublicKey restorePublicKey(byte[] keyBytes) {
        X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(keyBytes);
        try {
            KeyFactory factory = KeyFactory.getInstance(KEY_ALGORITHM);
            PublicKey publicKey = factory.generatePublic(x509EncodedKeySpec);
            return publicKey;
        } catch (NoSuchAlgorithmException | InvalidKeySpecException ex) {
            ex.printStackTrace();
        }
        return null;
    }

    /**
     * 还原私钥
     *
     * @param keyBytes
     * @return
     */
    public static PrivateKey restorePrivateKey(byte[] keyBytes) {
        PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(keyBytes);
        try {
            KeyFactory factory = KeyFactory.getInstance(KEY_ALGORITHM);
            PrivateKey privateKey = factory.generatePrivate(pkcs8EncodedKeySpec);
            return privateKey;
        } catch (NoSuchAlgorithmException | InvalidKeySpecException ex) {
            ex.printStackTrace();
        }
        return null;
    }

    /**
     * 生成签名
     *
     * @param privateKey
     * @param plain_text
     * @return
     */
    public static byte[] sign(PrivateKey privateKey, String plain_text) {
        MessageDigest messageDigest;
        byte[] signBytes = null;
        try {
            messageDigest = MessageDigest.getInstance(ENCODE_ALGORITHM);
            messageDigest.update(plain_text.getBytes());
            byte[] outputDigest_sign = messageDigest.digest();
            Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
            signature.initSign(privateKey);
            signature.update(outputDigest_sign);
            signBytes = signature.sign();
        } catch (NoSuchAlgorithmException | InvalidKeyException | SignatureException e) {
            e.printStackTrace();
        }
        return signBytes;
    }

    /**
     * 生成签名
     *
     * @param privateKeyString
     * @param plain_text
     * @return
     */
    public static String sign(String privateKeyString, String plain_text) {
        PrivateKey privateKey = restorePrivateKey(Base64Utils.decode(privateKeyString.getBytes()));
        MessageDigest messageDigest;
        byte[] signBytes = null;
        try {
            messageDigest = MessageDigest.getInstance(ENCODE_ALGORITHM);
            messageDigest.update(plain_text.getBytes());
            byte[] outputDigest_sign = messageDigest.digest();
            Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
            signature.initSign(privateKey);
            signature.update(outputDigest_sign);
            signBytes = signature.sign();
        } catch (NoSuchAlgorithmException | InvalidKeyException | SignatureException e) {
            e.printStackTrace();
        }
        return new String(Base64Utils.encode(signBytes));
    }

    /**
     * 验签
     *
     * @param publicKey
     * @param plain_text
     * @param signBytes
     * @return
     */
    public static boolean verifySign(PublicKey publicKey, String plain_text, byte[] signBytes) {
        MessageDigest messageDigest;
        boolean success = false;
        try {
            messageDigest = MessageDigest.getInstance(ENCODE_ALGORITHM);
            messageDigest.update(plain_text.getBytes());
            byte[] outputDigest_verify = messageDigest.digest();
            Signature verifySign = Signature.getInstance(SIGNATURE_ALGORITHM);
            verifySign.initVerify(publicKey);
            verifySign.update(outputDigest_verify);
            success = verifySign.verify(signBytes);
        } catch (NoSuchAlgorithmException | InvalidKeyException | SignatureException e) {
            e.printStackTrace();
        }
        return success;
    }

    /**
     * 验签
     *
     * @param publicKeyString
     * @param plain_text
     * @param sign
     * @return
     */
    public static boolean verifySign(String publicKeyString, String plain_text, String sign) {
        PublicKey publicKey = restorePublicKey(Base64Utils.decode(publicKeyString.getBytes()));
        MessageDigest messageDigest;
        boolean success = false;
        try {
            messageDigest = MessageDigest.getInstance(ENCODE_ALGORITHM);
            messageDigest.update(plain_text.getBytes());
            byte[] outputDigest_verify = messageDigest.digest();
            Signature verifySign = Signature.getInstance(SIGNATURE_ALGORITHM);
            verifySign.initVerify(publicKey);
            verifySign.update(outputDigest_verify);
            success = verifySign.verify(Base64Utils.decode(sign.getBytes()));
        } catch (NoSuchAlgorithmException | InvalidKeyException | SignatureException e) {
            e.printStackTrace();
        }
        return success;
    }

}
// 测试类

public void test() {
        /*生成秘钥对*/
        Map<String, byte[]> map = RSAUtil.generateKeyBytes();
        String privateKeyString = new String(Base64Utils.encode(map.get(RSAUtil.PRIVATE_KEY)));
        String publicKeyString = new String(Base64Utils.encode(map.get(RSAUtil.PUBLIC_KEY)));
        /*生成24位3DES秘钥*/
        String desKey = DESUtil.getRandomStringByLength(24);
        System.out.println("privateKeyString=" + privateKeyString);
        System.out.println("publicKeyString=" + publicKeyString);
        System.out.println("3deskey=" + desKey);
        /*生成签名，方法1*/
        String content = "{\"order_no\":\"test_order_no\",\"activity_id\":\"test_activity_id\",\"order_datetime\":\"20181010101012\",\"textField\":\"jijijijijijjjjjijijiiiiiiiiiiiiiiiiiii\"}";
        PrivateKey privateKey = RSAUtil.restorePrivateKey(Base64Utils.decode(privateKeyString.getBytes()));
        String sign = new String(Base64Utils.encode(RSAUtil.sign(privateKey, content)));
        System.out.println("sign=" + sign);
        /*验签，方法1*/
        PublicKey publicKey = RSAUtil.restorePublicKey(Base64Utils.decode(publicKeyString.getBytes()));
        boolean checkSign = RSAUtil.verifySign(publicKey, content, Base64Utils.decode(sign.getBytes()));
        System.out.println("checkSign=" + checkSign);
        /*生成签名，方法2*/
        sign = RSAUtil.sign(privateKeyString, content);
        System.out.println("sign=" + sign);
        /*验签，方法2*/
        checkSign = RSAUtil.verifySign(publicKeyString, content, sign);
        System.out.println("checkSign=" + checkSign);
        /*加密*/
        byte[] encryptBs = DESUtil.encrypt(content, desKey);
        String encryptData = new String(Base64Utils.encode(encryptBs));
        System.out.println("encryptData=" + encryptData);
        /*解密*/
        content = new String(DESUtil.decrypt(Base64Utils.decode(encryptData.getBytes()), desKey));
        System.out.println("decryptData=" + content);
    }


还可以找网站去生成一套不同位数的公私钥；