rsa秘钥的生成与加密解密

生成秘钥

public class KeyUtils {

    public class Keys {

    }
    public static final String KEY_ALGORITHM = "RSA";
    private static final String PUBLIC_KEY = "RSAPublicKey";
    private static final String PRIVATE_KEY = "RSAPrivateKey";

    //获得公钥
    public static String getPublicKey(Map<String, Object> keyMap) throws Exception {
        //获得map中的公钥对象 转为key对象
        Key key = (Key) keyMap.get(PUBLIC_KEY);
        //编码返回字符串
        return encryptBASE64(key.getEncoded());
    }

    //获得私钥
    public static String getPrivateKey(Map<String, Object> keyMap) throws Exception {
        //获得map中的私钥对象 转为key对象
        Key key = (Key) keyMap.get(PRIVATE_KEY);
        //编码返回字符串
        return encryptBASE64(key.getEncoded());
    }

    //解码返回byte
    public static byte[] decryptBASE64(String key) throws Exception {
        return (new BASE64Decoder()).decodeBuffer(key);
    }

    //编码返回字符串
    public static String encryptBASE64(byte[] key) throws Exception {
        return (new BASE64Encoder()).encodeBuffer(key);
    }

    //map对象中存放公私钥
    public static Map<String, Object> initKey() throws Exception {
        //获得对象 KeyPairGenerator 参数 RSA 1024个字节
        KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
        keyPairGen.initialize(1024);
        //通过对象 KeyPairGenerator 获取对象KeyPair
        KeyPair keyPair = keyPairGen.generateKeyPair();
        //通过对象 KeyPair 获取RSA公私钥对象RSAPublicKey RSAPrivateKey
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
        //公私钥对象存入map中
        Map<String, Object> keyMap = new HashMap<String, Object>(2);
        keyMap.put(PUBLIC_KEY, publicKey);
        keyMap.put(PRIVATE_KEY, privateKey);
        return keyMap;
    }

    public static List getPubAndPri() {
        Map<String, Object> keyMap;
        try {
            keyMap = initKey();
            String publicKey = getPublicKey(keyMap);
            String privateKey = getPrivateKey(keyMap);
            List<String> list = new ArrayList<>();
            list.add(publicKey);
            list.add(privateKey);
            return list;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}

加密解密与校验

package com.jpxx.admin.common.util;

import org.apache.commons.codec.binary.Base64;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import java.io.ByteArrayOutputStream;
import java.io.UnsupportedEncodingException;
import java.security.*;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.List;
import java.util.Set;

/**
 * @ClassName RSAUtils
 * @Description
 * @Author Administrator
 * @Date 2020/10/27 0027 15:05
 * @Version 1.0
 */
public class RSAUtils {
    // 加密方式
    public static final String ALGORITHM = "RSA";
    // 签名算法
    private static final String SIGNATURE_ALGORITHM = "SHA1WithRSA";
    // 创建密钥对bai初始长度du
    private static final int KEY_SIZE = 512;
    // 字符编码格式
    private static final String CHARSET = "UTF-8";
    // RSA最大加密明文大小
    private static final int MAX_ENCRYPT_BLOCK = 117;
    // RSA最大解密密文大小
    private static final int MAX_DECRYPT_BLOCK = 128;

    private KeyFactory keyFactory;

    public RSAUtils() throws NoSuchAlgorithmException {
        keyFactory = KeyFactory.getInstance(ALGORITHM);
    }

    /**
     * 私钥加密
     *
     * @param content    待加密字符串
     * @param privateKey 私钥
     * @return 加密后字符串（BASE64编码）
     */
    public String encryptByPrivateKey(String content, String privateKey) throws Exception {
        String result;

        try (ByteArrayOutputStream out = new ByteArrayOutputStream()) {
            byte[] keyBytes = new Base64().decode(privateKey);
            PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
            PrivateKey pKey = keyFactory.generatePrivate(pkcs8KeySpec);
            Cipher cipher = Cipher.getInstance(ALGORITHM);
            cipher.init(Cipher.ENCRYPT_MODE, pKey);

            byte[] data = content.getBytes(CHARSET);
            write2Stream(cipher, data, out);
            byte[] resultBytes = out.toByteArray();

            result = Base64.encodeBase64String(resultBytes);
        } catch (Exception e) {
            throw new Exception(e);
        }

        return result;
    }

    /**
     * 公钥解密
     *
     * @param content   已加密字符串（BASE64加密）
     * @param publicKey 公钥
     * @return
     */
    public String decryptByPublicKey(String content, String publicKey) throws Exception {
        String result = "";

        try (ByteArrayOutputStream out = new ByteArrayOutputStream()) {
            byte[] keyBytes = new Base64().decode(publicKey);
            X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
            PublicKey pKey = keyFactory.generatePublic(x509KeySpec);
            Cipher cipher = Cipher.getInstance(ALGORITHM);
            cipher.init(Cipher.DECRYPT_MODE, pKey);

            byte[] data = Base64.decodeBase64(content);
            write2Stream(cipher, data, out);
            byte[] resultBytes = out.toByteArray();

            result = new String(resultBytes);
        } catch (Exception e) {
            throw new Exception(e);
        }

        return result;
    }

    /**
     * 公钥加密
     *
     * @param content   待加密字符串
     * @param publicKey 公钥
     * @return 加密后字符串（BASE64编码）
     */
    public String encryptByPublicKey(String content, String publicKey) throws Exception {
        String result = "";

        try (ByteArrayOutputStream out = new ByteArrayOutputStream()) {
            byte[] keyBytes = new Base64().decode(publicKey);
            X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
            PublicKey pKey = keyFactory.generatePublic(x509KeySpec);
            Cipher cipher = Cipher.getInstance(ALGORITHM);
            cipher.init(Cipher.ENCRYPT_MODE, pKey);

            byte[] data = content.getBytes(CHARSET);
            write2Stream(cipher,
                    data, out);
            byte[] resultBytes = out.toByteArray();
            result = Base64.encodeBase64String(resultBytes);
        } catch (Exception e) {
            throw new Exception(e);
        }

        return result;
    }

    /**
     * 私钥解密
     *
     * @param content    已加密字符串
     * @param privateKey 私钥
     * @return 解密后字符串
     */
    public String decryptByPrivateKey(String content, String privateKey) throws Exception {
        String result = "";

        try (ByteArrayOutputStream out = new ByteArrayOutputStream()) {
            byte[] keyBytes = new Base64().decode(privateKey);
            PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
            PrivateKey pKey = keyFactory.generatePrivate(pkcs8KeySpec);
            Cipher cipher = Cipher.getInstance(ALGORITHM);
            cipher.init(Cipher.DECRYPT_MODE, pKey);

            byte[] data = Base64.decodeBase64(content);
            write2Stream(cipher, data, out);
            byte[] resultBytes = out.toByteArray();
            result = new String(resultBytes);
        } catch (Exception e) {
            throw new Exception(e);
        }

        return result;
    }

    private static void write2Stream(Cipher cipher, byte[] data, ByteArrayOutputStream out) throws
            BadPaddingException, IllegalBlockSizeException {
        int dataLen = data.length;
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段解密
        while (dataLen - offSet > 0) {
            if (dataLen - offSet > MAX_DECRYPT_BLOCK) {
                cache = cipher.doFinal(data, offSet, MAX_DECRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(data, offSet, dataLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_DECRYPT_BLOCK;
        }
    }

    /**
     * 用私钥对信息生成数字签名
     *
     * @param data       已加密数据
     * @param privateKey 私钥(BASE64编码)
     * @return sign
     */
    public String sign(String data, String privateKey) throws Exception {
        String result = "";
        try {
            byte[] keyBytes = new Base64().decode(privateKey);
            PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
            PrivateKey privateK = keyFactory.generatePrivate(pkcs8KeySpec);
            Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
            signature.initSign(privateK);
            signature.update(parse2HexStr(data).getBytes(CHARSET));

            result = new Base64().encodeToString(signature.sign());
        } catch (Exception e) {
            throw new Exception(e);
        }
        return result;
    }

    /**
     * 校验数字签名
     *
     * @param data      已加密数据
     * @param publicKey 公钥(BASE64编码)
     * @param sign      数字签名
     * @return
     * @throws Exception
     */
    public boolean verify(String data, String publicKey, String sign) throws Exception {
        boolean result;

        try {
            byte[] keyBytes = new Base64().decode(publicKey);
            X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
            PublicKey publicK = keyFactory.generatePublic(keySpec);
            Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
            signature.initVerify(publicK);
            signature.update(parse2HexStr(data).getBytes(CHARSET));
            result = signature.verify(new Base64().decode(sign));
        } catch (Exception e) {
            throw new Exception(e);
        }
        return result;
    }

    /**
     * 将二进制转换成16进制
     *
     * @param data
     * @return
     */
    public static String parse2HexStr(String data) throws Exception {
        String result = "";
        try {
            byte[] buf = data.getBytes(CHARSET);

            StringBuffer sb = new StringBuffer();
            for (int i = 0; i < buf.length; i++) {
                String hex = Integer.toHexString(buf[i] & 0xFF);
                if (hex.length() == 1) {
                    hex = '0' + hex;
                }
                sb.append(hex.toUpperCase());
            }
            result = sb.toString();
        } catch (UnsupportedEncodingException e) {
            throw new Exception(e);
        }
        return result;
    }

    /**
     * 生成公钥与私钥
     */
    public static void createKey() throws Exception {
        try {
            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(ALGORITHM);
            keyPairGenerator.initialize(KEY_SIZE);
            KeyPair keyPair = keyPairGenerator.generateKeyPair();
            RSAPublicKey rsaPublicKey = (RSAPublicKey) keyPair.getPublic();
            RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) keyPair.getPrivate();

            String publicKey = Base64.encodeBase64String(rsaPublicKey.getEncoded());
            String privateKey = Base64.encodeBase64String(rsaPrivateKey.getEncoded());

            System.out.println("publicKey=" + publicKey + "\nprivateKey=" + privateKey);
        } catch (NoSuchAlgorithmException e) {
            throw new Exception(e);
        }
    }

    public static void main(String[] args) throws Exception {

        //String PRIVATE_KEY = "MIICeAIBADANBgkqhkiG9w0BAQEFAASCAmIwggJeAgEAAoGBAKeYGXH6Vz+m+KuL11RDRaNdHB4YQeZgqpJGPRSwBelgvEoHu2/fNs1bmgfJhI8lhr/o/Hy8EFB/I/DDyLcCcU4bCLtxpki8edC+KJR2WvyYfnVmWEe/3q2jSVKRf81868q9Cd3MMfrQPMsY4x0TQ0GtOf/nMSMbAltV2W8J86IfAgMBAAECgYEApYu4lr2SMW3ddJZNvQ42W4g9nfyYG9igpJx8+VJmhIDpfLbmjzsOBwvUupx0NHH9CNQ7k3qxItJzzf+W5C+lesEOAqdO5nahRZsL8BIDoxTEn2j+1GXkzQw3vqPY50xqRnZsoP5TyNNsOM7KYaOoz4VFMdVIFwoT3OKM5z7mxgECQQD51r17WZDSa/kucaH7gCOePxJPS6Ust0eVd5tBOMpFzD/VtziogSIWyhGKkLH0SyTJEe91CCpdpxufLSZgIiN5AkEAq7ojtvU4twak1N1/1qX+t8f5wD8i/8GU702PeCwkGI5ymrARq+W2yCuvU1bouXBhjKHV4KhafKYixdHUMg00VwJAYVUjpLaUESY3gbyLWqvlNHVl8LaLtwwAO17JgXNaei7Ef8JNtHf6i95VTyJn8cCEqEDwhSuVNb8wp6azWKh0IQJBAJHrcT2d0bt0IcvfCynRk0eG3WnGPG8mhu9w8GAk4ecb47YdtmZio5YjyK8AQnCQVdOyEJL9eyY/5XxCeBSvs7ECQQCKQ2f5HLDkkHvc6rlaHCJmqNRCS+CxhoaiaSPYLAac7WXmb614ACLECc86C/nkefTq0SNpUDVbGxVpJi9/FOUf";
        //String PUBLIC_KEY = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCnmBlx+lc/pviri9dUQ0WjXRweGEHmYKqSRj0UsAXpYLxKB7tv3zbNW5oHyYSPJYa/6Px8vBBQfyPww8i3AnFOGwi7caZIvHnQviiUdlr8mH51ZlhHv96to0lSkX/NfOvKvQndzDH60DzLGOMdE0NBrTn/5zEjGwJbVdlvCfOiHwIDAQAB";

        List pubAndPri = KeyUtils.getPubAndPri();
        String PUBLIC_KEY = (String) pubAndPri.get(0);
        String PRIVATE_KEY = (String) pubAndPri.get(1);
        System.out.println(pubAndPri);
        RSAUtils rsaUtil = new RSAUtils();

        //公钥加密
        String encryptByPublicKey = rsaUtil.encryptByPublicKey("测试公钥加密", PUBLIC_KEY);

        //私钥解密
        String decryptByPrivateKey = rsaUtil.decryptByPrivateKey(encryptByPublicKey, PRIVATE_KEY);
        System.out.println("私钥解密:"+decryptByPrivateKey);

        //私钥加密
        String encryptByPrivateKey = rsaUtil.encryptByPrivateKey("测试私钥加密", PRIVATE_KEY);

        //公钥解密
        String decryptByPublicKey = rsaUtil.decryptByPublicKey(encryptByPrivateKey, PUBLIC_KEY);
        System.out.println("公钥解密:"+decryptByPublicKey);

        //用私钥对信息生成数字签名
        String sign = rsaUtil.sign("000", PRIVATE_KEY);
        System.out.println(sign);

        //校验数字签名
        System.out.println(rsaUtil.verify("000", PUBLIC_KEY, sign));
    }
}