算法简介

RSA加密算法是一种非对称加密算法，在公开密钥加密和电子商业中RSA被广泛使用。

算法实现

1、RSAUtils.java

package juice.core.util.codec;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.security.*;
import java.security.interfaces.RSAKey;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;

/**
 * @author Ricky Fung
 */
public abstract class RSAUtils {

    private static final String RSA_ALGORITHM = "RSA";

    //--------------------------------------------
    /** 公钥加密 **/
    public static byte[] encryptWithPublicKey(final byte[] data, RSAPublicKey publicKey) {
        return doRSA(publicKey, Cipher.ENCRYPT_MODE, data);
    }

    /** 公钥解密 **/
    public static byte[] decryptByPublicKey(final byte[] data, RSAPublicKey publicKey) {
        return doRSA(publicKey, Cipher.DECRYPT_MODE, data);
    }

    //---------------------------------------------------

    /** 私钥解密 **/
    public static byte[] decryptWithPrivateKey(byte[] data, RSAPrivateKey privateKey) {
        return doRSA(privateKey, Cipher.DECRYPT_MODE, data);
    }

    /** 私钥加密 **/
    public static byte[] encryptWithPrivateKey(byte[] data, RSAPrivateKey privateKey){
        return doRSA(privateKey, Cipher.ENCRYPT_MODE, data);
    }

    private static byte[] doRSA(RSAKey key, int mode, byte[] data) {
        try{
            Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
            cipher.init(mode, (Key) key);
            return doRSA(cipher, mode, data, key.getModulus().bitLength());
        }catch(Exception e){
            throw new IllegalArgumentException(e);
        }
    }

    private static byte[] doRSA(Cipher cipher, int mode, byte[] data, int keySize) throws IOException, BadPaddingException, IllegalBlockSizeException {
        int maxBlock;
        if(mode == Cipher.DECRYPT_MODE){
            maxBlock = keySize / 8;
        }else{
            maxBlock = keySize / 8 - 11;
        }
        int length = data.length;
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        try {
            int offset = 0;
            byte[] buf;
            int i = 0;
            // 对数据分段加密
            while (length - offset > 0) {
                if (length - offset > maxBlock) {
                    buf = cipher.doFinal(data, offset, maxBlock);
                } else {
                    buf = cipher.doFinal(data, offset, length - offset);
                }
                baos.write(buf, 0, buf.length);
                i++;
                offset = i * maxBlock;
            }
            baos.flush();
            return baos.toByteArray();
        } finally {
            baos.close();
        }
    }

    //------------------------------
    /**
     * generate publicKey
     * @param publicKey
     * @return
     */
    public static RSAPublicKey generatePublicKey(String publicKey) {
        try {
            KeyFactory keyFactory = KeyFactory.getInstance(RSA_ALGORITHM);
            X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(Base64Utils.decode(publicKey));
            RSAPublicKey key = (RSAPublicKey) keyFactory.generatePublic(x509KeySpec);
            return key;
        } catch (Exception e) {
            throw new IllegalArgumentException("generate publicKey caught error", e);
        }
    }

    /**
     * generate privateKey
     * @param privateKey
     * @return
     */
    public static RSAPrivateKey generatePrivateKey(String privateKey) {
        try {
            KeyFactory keyFactory = KeyFactory.getInstance(RSA_ALGORITHM);
            PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(Base64Utils.decode(privateKey));
            RSAPrivateKey key = (RSAPrivateKey) keyFactory.generatePrivate(pkcs8KeySpec);
            return key;
        } catch (Exception e) {
            throw new IllegalArgumentException("generate privateKey caught error", e);
        }
    }

    //------------------------------

    public static String getPublicKey(PublicKey publicKey) {
        return Base64Utils.encodeString(publicKey.getEncoded());
    }

    public static String getPrivateKey(PrivateKey privateKey) {
        return Base64Utils.encodeString(privateKey.getEncoded());
    }

    //------------------------------
    /**
     * generate KeyPair
     * @return
     * @throws NoSuchAlgorithmException
     */
    public static KeyPair generateKeyPair(int keySize) throws NoSuchAlgorithmException {
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(RSA_ALGORITHM);
        keyPairGenerator.initialize(keySize);
        return keyPairGenerator.genKeyPair();
    }
}

2、测试用例：

package juice.core.codec;

import juice.core.util.CharsetUtils;
import juice.core.util.codec.Base64Utils;
import juice.core.util.codec.RSAUtils;
import org.junit.Test;

import java.security.KeyPair;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;

/**
 * @author Ricky Fung
 */
public class RSAUtilsTest {

    @Test
    public void testRSA() throws NoSuchAlgorithmException {

        KeyPair keyPair = RSAUtils.generateKeyPair(1024);
        PublicKey pubKey = keyPair.getPublic();
        PrivateKey priKey = keyPair.getPrivate();

        String  publicKey = RSAUtils.getPublicKey(pubKey);
        String  privateKey = RSAUtils.getPrivateKey(priKey);

        System.out.println("公钥：" + publicKey);
        System.out.println("私钥：" + privateKey);

        String content = "站在大明门前守卫的禁卫军，事先没有接到有关的命令。hello world!";
        byte[] data = content.getBytes(CharsetUtils.CHARSET_UTF_8);

        System.out.println("明文：" + content);
        System.out.println("明文大小：" + data.length);

        //公钥加密
        byte[] encodeBuf = RSAUtils.encryptWithPublicKey(data,  RSAUtils.generatePublicKey(publicKey));
        System.out.println("密文：" + Base64Utils.encodeString(encodeBuf));
        System.out.println("密文大小：" + encodeBuf.length);

        //私钥解密
        byte[] decodeBuf = RSAUtils.decryptWithPrivateKey(encodeBuf, RSAUtils.generatePrivateKey(privateKey));
        System.out.println("解密后文字：" + new String(decodeBuf, CharsetUtils.CHARSET_UTF_8));

    }

}

3、运行结果

公钥：MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCJCg0Ftta9vPZ4Vjr2b5QenUhRMl7++mfUxJjyRVIIm4hBhriXVLBxw8DbTYuWoh/LxFyR1e7z1h9fDZNNb7Pr+LAN+tFcpHDgSkItNiOsQXI9ElWRWu4eMSxT/7ihxwAO261LHXDElxoTZsEPhPWVAoL7FSUKMKGspAK4SRqFIwIDAQAB
私钥：MIICdwIBADANBgkqhkiG9w0BAQEFAASCAmEwggJdAgEAAoGBAIkKDQW21r289nhWOvZvlB6dSFEyXv76Z9TEmPJFUgibiEGGuJdUsHHDwNtNi5aiH8vEXJHV7vPWH18Nk01vs+v4sA360VykcOBKQi02I6xBcj0SVZFa7h4xLFP/uKHHAA7brUsdcMSXGhNmwQ+E9ZUCgvsVJQowoaykArhJGoUjAgMBAAECgYEAg1qQ9OM2npPbo6jzx3dYAKg9wyaHC9w1Xio7eC2d3gZG6pgZo2RX5BQAbbS8kdxAoe5L1LW83xhk5ZV7lgP17lFgBMs9O7bUe29hvDuwzA8qjB1MICmAWpqQfO4b6t94Y7BNEVQb2uYqQly7cv9hkP0R3RubAJUtScFaYq2FnRECQQDj/euxXjC8ur7BBy0yKyiXNtupkAK/v7gXGGLa0VahG85nbG8ZoP84mEELtWM0dZQuJVuF4Lpw9lDVdpBHDONfAkEAmd/GteisfutWKiIqvjCbdvRaAEXVEavqpF0N5ZQdBtMlsW+xoq9gbL3KiQYEimH90cU3PkAIHwGzl/RkrlJYvQJBALU7o5/av+NGj1vh2IuIwztw4CxpzcWfITc6q1pGDhcDg4+zIp283SSf4xTrm3CYBrKn/5jsi0hAhQEqvoW8OQECQFtmunF5yWUGw8L5Uqxw0Rgi44c/8+WwWgvSHpwdk/Rm3f/9GeZKCJvvTOyBv5a3yH6fiEYY4PoSF60OhfOqhH0CQC7+8uFBkbH9Sor+TXqHCKgUBGlUhXWctYTtuEosDhjBzGPp8sX4UWjR6a1zN72nsjtgnkNGW+Ok7V5lYqWWKmg=
明文：站在大明门前守卫的禁卫军，事先没有接到有关的命令。hello world!
明文大小：87
密文：DTayju55McnIs2rX53vXPJFNbhlXBTUURctlPEQrrtawzI0498NVmg4ATgGALmiFoP7eL4S1n+P9Tpw23Sno+gHGglxcqZaWkfdghqIH5eMGcbnmuOhR5cAgbBbshablNWL0cmbjraxtG3JK7umc/LxeDjk82peh+dX65IN/kNk=
密文大小：128
解密后文字：站在大明门前守卫的禁卫军，事先没有接到有关的命令。hello world!

源代码

Juice - RSAUtils