RSA非对称加密和解密（同时生成密钥）

RSA非对称加密和解密（同时生成密钥）

准备jar包

bcprov-jdk16-1.46.jar

commons-codec-1.15.jar

获取jar地址：https://mvnrepository.com/artifact/org.bouncycastle/bcprov-jdk16/1.46

https://mvnrepository.com/artifact/commons-codec/commons-codec

代码准备

4个类：

CipherCharset

RsaBase64KeyPair

RsaUtils

TestRsaJava

CipherCharset：

package com.rsa;

import java.nio.charset.Charset;

public class CipherCharset {

    public static String CIPHER_CHARSET = Charset.defaultCharset().name();
    public static final String CIPHER_CHARSET_GBK = "GBK";
    public static final String CIPHER_CHARSET_UTF8 = "UTF-8";

    public static void initCharset(String charset) {
        CIPHER_CHARSET = charset;
    }

    public static void initGBK() {
        CIPHER_CHARSET = CIPHER_CHARSET_GBK;
    }

    public static void initUTF8() {
        CIPHER_CHARSET = CIPHER_CHARSET_UTF8;
    }

    public static String getCharset() {
        return CIPHER_CHARSET;
    }
}

RsaBase64KeyPair：

package com.rsa;

public class RsaBase64KeyPair {
    private String rsaPubBase64;
    private String rsaPriBase64;

    public RsaBase64KeyPair(String rsaPubBase64, String rsaPriBase64) {
        this.rsaPubBase64 = rsaPubBase64;
        this.rsaPriBase64 = rsaPriBase64;
    }
    public String getRsaPubBase64() {
        return rsaPubBase64;
    }
    public void setRsaPubBase64(String rsaPubBase64) {
        this.rsaPubBase64 = rsaPubBase64;
    }
    public String getRsaPriBase64() {
        return rsaPriBase64;
    }
    public void setRsaPriBase64(String rsaPriBase64) {
        this.rsaPriBase64 = rsaPriBase64;
    }
}

RsaUtils：

package com.rsa;

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

import javax.crypto.Cipher;
import java.security.*;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;

public class RsaUtils {

    // springboot项目可以放入application.properties中
    public static final String KEY_ALGORITHM = "RSA";
    static {
        try {
           Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static byte[] subarray(byte[] array, int startIndexInclusive, int endIndexExclusive) {
        if (array == null) {
            return null;
        }
        if (startIndexInclusive < 0) {
            startIndexInclusive = 0;
        }
        if (endIndexExclusive > array.length) {
            endIndexExclusive = array.length;
        }
        int newSize = endIndexExclusive - startIndexInclusive;

        if (newSize <= 0) {
            return new byte[0];
        }

        byte[] subarray = new byte[newSize];

        System.arraycopy(array, startIndexInclusive, subarray, 0, newSize);

        return subarray;
    }

    public static byte[] addAll(byte[] array1, byte[] array2) {
        if (array1 == null) {
            return clone(array2);
        } else if (array2 == null) {
            return clone(array1);
        }
        byte[] joinedArray = new byte[array1.length + array2.length];
        System.arraycopy(array1, 0, joinedArray, 0, array1.length);
        System.arraycopy(array2, 0, joinedArray, array1.length, array2.length);
        return joinedArray;
    }

    public static byte[] clone(byte[] array) {
        if (array == null) {
            return null;
        }
        return (byte[]) array.clone();
    }

    //还原私钥对象
    public static PrivateKey genPrivateKey(String base64Rsa) {

        try {
            KeyFactory kf = KeyFactory.getInstance(KEY_ALGORITHM, "BC");
            PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(Base64.decodeBase64(base64Rsa));
            return kf.generatePrivate(keySpec);
        } catch (Exception e) {
            e.printStackTrace();
            throw new IllegalArgumentException("初始化秘钥异常");
        }
    }

    /**
     * 私钥加密
     */
    public static byte[] encryptByKey(byte[] srcData, Key publicKey) {
        try {
            Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
            cipher.init(Cipher.ENCRYPT_MODE, publicKey);
            // 分段加密
            int blockSize = cipher.getOutputSize(srcData.length) - 11;
            byte[] encryptedData = null;
            for (int i = 0; i < srcData.length; i += blockSize) {
                // 注意要使用2的倍数，否则会出现加密后的内容再解密时为乱码
                byte[] doFinal = cipher.doFinal(RsaUtils.subarray(srcData, i, i + blockSize));
                encryptedData = RsaUtils.addAll(encryptedData, doFinal);
            }
            return encryptedData;

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

    //还原公钥对象
    public static PublicKey genPublicKey(String base64Rsa) {
        try {
            KeyFactory kf = KeyFactory.getInstance(KEY_ALGORITHM, "BC");
            X509EncodedKeySpec keySpec = new X509EncodedKeySpec(Base64.decodeBase64(base64Rsa));
            return kf.generatePublic(keySpec);
        } catch (Exception e) {
            e.printStackTrace();
            throw new IllegalArgumentException("初始化秘钥失败");
        }
    }

    public static byte[] decryptKey(byte[] srcData, Key key) {
        try {
            Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
            cipher.init(Cipher.DECRYPT_MODE, key);
            // 分段加密
            int blockSize = cipher.getOutputSize(srcData.length);
            byte[] decryptData = null;

            for (int i = 0; i < srcData.length; i += blockSize) {
                byte[] doFinal = cipher.doFinal(subarray(srcData, i, i + blockSize));

                decryptData = addAll(decryptData, doFinal);
            }
            return decryptData;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

}

TestRsaJava：

package com.rsa;

import org.apache.commons.codec.binary.Base64;
import java.security.*;
import java.util.UUID;

public class TestRsaJava {

    /**
     * 生成密钥对(公钥和私钥)
     *
     * @return
     * @throws Exception
     */
    public static RsaBase64KeyPair genKeyPair(int size) {
        try {
            KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(RsaUtils.KEY_ALGORITHM);
            keyPairGen.initialize(size);
            KeyPair keyPair = keyPairGen.generateKeyPair();
            byte[] publicBytes = keyPair.getPublic().getEncoded();
            byte[] privateBytes = keyPair.getPrivate().getEncoded();
            return new RsaBase64KeyPair(Base64.encodeBase64String(publicBytes),
                    Base64.encodeBase64String(privateBytes));
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }

    }

    /**
     * RSA 私钥加密
     * @param src
     * @param base64PubRsa
     * @return
     */
    public static String encryptByRsaPri(String src, String base64PubRsa) {
        try {
            PrivateKey privateKey = RsaUtils.genPrivateKey(base64PubRsa);
            byte[] encryptBytes = RsaUtils.encryptByKey(src.getBytes(CipherCharset.getCharset()), privateKey);
            return Base64.encodeBase64String(encryptBytes);
        } catch (Exception e) {
            e.printStackTrace();
            throw new IllegalArgumentException("rsa加密失败");
        }
    }

    public static String decryptByRsaPub(String base64Src, String base64PriRsa) {
        try {
            PublicKey publicKey = RsaUtils.genPublicKey(base64PriRsa);
            return new String(RsaUtils.decryptKey(Base64.decodeBase64(base64Src), publicKey), CipherCharset.getCharset());
        } catch (Exception e) {
            e.printStackTrace();
            throw new IllegalArgumentException("rsa解密失败");
        }
    }

    public static void main(String[] args) {
        // 生成公钥和私钥
//        RsaBase64KeyPair keyPair = genKeyPair(1024);
        // MIICdQIBADANBgkqhkiG9w0BAQEFAASCAl8wggJbAgEAAoGBAIjAJ+CfLf0HzyFcfCd9FgRjDpGQ+GCoJp2He/eemOW9UXCpj0t5NwDP4UyPFxpUsv/5/ZyhQlDNKn2qo6IJkSNmbKp13vL81b3BsiLo9NjqNfQwb+SQdK8VLhua71dlyqp/EAC4QF9H0cIn0RK4WAi/WAaklD/Z3r32M7L6dyYNAgMBAAECgYBVX7nFpzsb1EtBJa8xLAuZ04nd4SbfmTr6cAI59l64VzhH4OPgF536OM4McOzYeHaEDruBlL+FGIFlkSm1WMmt32aQXkziKw6RPECocePjN6ao+1i7rrbBItOoNcURgm6s1iUtei/q3EE4QgdV/SG1jhUIED+mPgjz/Uoxu5sbwQJBAPrDNkIomkN3CblmV0UaoPMLAN8wuwcl8bEmZ8Baw5IobAvMcqGDgA1Ha+sJ/SQVkOZ8g0hiiy/rd/atpJmOMDECQQCLm1cAhFhPv9IUPB+3a/2XfQlkPo+4iB9eqB9QHspAii2m06JqRVWIVn08JfUIwh3Zer/pk4dkH1JZAiE87xidAkAMeUFtsQ9bY8R8EHcu3NA8xsNYVtg21tBa+4oVq24nCxO00oqxNhVck7zuiCSrctcuX+s34o8B5zikcKbLbKNBAkAAnZm/ndXJ3D2v6yf0phxDK8D72S7HEIqa30DsGIapzDIxVyOTNmUPKdp5hm1TMY/yIpFwFT92mJDDZbgBzcgdAkBSDisYn/P/wn8Wjuggao6QcIDbKhSbhJ9hVtGLteBXXCisDjCLUL8teb7xX6YS0QCOufrtB0LaxXSUKktNrjUl
//        System.out.println(keyPair.getRsaPriBase64());
        // MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCIwCfgny39B88hXHwnfRYEYw6RkPhgqCadh3v3npjlvVFwqY9LeTcAz+FMjxcaVLL/+f2coUJQzSp9qqOiCZEjZmyqdd7y/NW9wbIi6PTY6jX0MG/kkHSvFS4bmu9XZcqqfxAAuEBfR9HCJ9ESuFgIv1gGpJQ/2d699jOy+ncmDQIDAQAB
//        System.out.println(keyPair.getRsaPubBase64());

        String rsaPriBase64 = "MIICdQIBADANBgkqhkiG9w0BAQEFAASCAl8wggJbAgEAAoGBAIjAJ+CfLf0HzyFcfCd9FgRjDpGQ+GCoJp2He/eemOW9UXCpj0t5NwDP4UyPFxpUsv/5/ZyhQlDNKn2qo6IJkSNmbKp13vL81b3BsiLo9NjqNfQwb+SQdK8VLhua71dlyqp/EAC4QF9H0cIn0RK4WAi/WAaklD/Z3r32M7L6dyYNAgMBAAECgYBVX7nFpzsb1EtBJa8xLAuZ04nd4SbfmTr6cAI59l64VzhH4OPgF536OM4McOzYeHaEDruBlL+FGIFlkSm1WMmt32aQXkziKw6RPECocePjN6ao+1i7rrbBItOoNcURgm6s1iUtei/q3EE4QgdV/SG1jhUIED+mPgjz/Uoxu5sbwQJBAPrDNkIomkN3CblmV0UaoPMLAN8wuwcl8bEmZ8Baw5IobAvMcqGDgA1Ha+sJ/SQVkOZ8g0hiiy/rd/atpJmOMDECQQCLm1cAhFhPv9IUPB+3a/2XfQlkPo+4iB9eqB9QHspAii2m06JqRVWIVn08JfUIwh3Zer/pk4dkH1JZAiE87xidAkAMeUFtsQ9bY8R8EHcu3NA8xsNYVtg21tBa+4oVq24nCxO00oqxNhVck7zuiCSrctcuX+s34o8B5zikcKbLbKNBAkAAnZm/ndXJ3D2v6yf0phxDK8D72S7HEIqa30DsGIapzDIxVyOTNmUPKdp5hm1TMY/yIpFwFT92mJDDZbgBzcgdAkBSDisYn/P/wn8Wjuggao6QcIDbKhSbhJ9hVtGLteBXXCisDjCLUL8teb7xX6YS0QCOufrtB0LaxXSUKktNrjUl";
        String rsaPubBase64 = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCIwCfgny39B88hXHwnfRYEYw6RkPhgqCadh3v3npjlvVFwqY9LeTcAz+FMjxcaVLL/+f2coUJQzSp9qqOiCZEjZmyqdd7y/NW9wbIi6PTY6jX0MG/kkHSvFS4bmu9XZcqqfxAAuEBfR9HCJ9ESuFgIv1gGpJQ/2d699jOy+ncmDQIDAQAB";

        String str1 = UUID.randomUUID().toString();
        System.out.println(str1);

        // 加密之后的
        String encryptByRsaPub = encryptByRsaPri(str1, rsaPriBase64);
        System.out.println(encryptByRsaPub);
		
        // 解密之后的
        String decryptByRsaPri = decryptByRsaPub(encryptByRsaPub,rsaPubBase64);
        System.out.println(decryptByRsaPri);
    }

}