RSA算法是一种非对称加密算法，所谓非对称就是该算法需要一对密钥，若使用其中一个加密，则需要用另一个才能解密。目前它是最有影响力和最常用的公钥加密算法，能够抵抗已知的绝大多数密码攻击。从提出到现今的三十多年里，经历了各种攻击的考验，逐渐为人们接受，普遍认为是目前最优秀的公钥方案之一。
    该算法基于一个的数论事实：将两个大质数相乘十分容易，但是想要对其乘积进行因式分解却极其困难，因此可以将乘积公开作为加密密钥。由于进行的都是大数计算，RSA 最快的情况也比 DES 慢上好几倍，比对应同样安全级别的对称密码算法要慢 1000 倍左右。所以 RSA 一般只用于少量数据加密，比如说交换对称加密的密钥。
    使用 RSA 加密主要有这么几步：生成密钥对、公开公钥、公钥加密私钥解密、私钥加密公钥解密。
    示例代码：

    1. import com.sun.org.apache.xml.internal.security.utils.Base64;
    2. import javax.crypto.Cipher;
    4. import org.apache.commons.io.FileUtils;
    6. import java.io.ByteArrayOutputStream;
    7. import java.io.File;
    8. import java.nio.charset.Charset;
    9. import java.security.*;
    10. import java.security.spec.PKCS8EncodedKeySpec;
    11. import java.security.spec.X509EncodedKeySpec;
    13. public class RsaUtil {
    15.     /**
    16.      * 生成密钥对并保存在本地文件中
    17.      *
    18.      * @param algorithm : 算法
    19.      * @param pubPath   : 公钥保存路径
    20.      * @param priPath   : 私钥保存路径
    21.      * @throws Exception
    22.      */
    23.     private static void generateKeyToFile(String algorithm, String pubPath, String priPath) throws Exception {
    24.         // 获取密钥对生成器
    25.         KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
    26.         // 获取密钥对
    27.         KeyPair keyPair = keyPairGenerator.generateKeyPair();
    28.         // 获取公钥
    29.         PublicKey publicKey = keyPair.getPublic();
    30.         // 获取私钥
    31.         PrivateKey privateKey = keyPair.getPrivate();
    32.         // 获取byte数组
    33.         byte[] publicKeyEncoded = publicKey.getEncoded();
    34.         byte[] privateKeyEncoded = privateKey.getEncoded();
    35.         // 进行Base64编码
    36.         String publicKeyString = Base64.encode(publicKeyEncoded);
    37.         String privateKeyString = Base64.encode(privateKeyEncoded);
    38.         // 保存文件
    39.         FileUtils.writeStringToFile(new File(pubPath), publicKeyString, Charset.forName("UTF-8"));
    40.         FileUtils.writeStringToFile(new File(priPath), privateKeyString, Charset.forName("UTF-8"));
    42.     }
    44.     /**
    45.      * 从文件中加载公钥
    46.      *
    47.      * @param algorithm : 算法
    48.      * @param filePath  : 文件路径
    49.      * @return : 公钥
    50.      * @throws Exception
    51.      */
    52.     private static PublicKey loadPublicKeyFromFile(String algorithm, String filePath) throws Exception {
    53.         // 将文件内容转为字符串
    54.         String keyString = FileUtils.readFileToString(new File(filePath), Charset.forName("UTF-8"));
    56.         return loadPublicKeyFromString(algorithm, keyString);
    58.     }
    60.     /**
    61.      * 从字符串中加载公钥
    62.      *
    63.      * @param algorithm : 算法
    64.      * @param keyString : 公钥字符串
    65.      * @return : 公钥
    66.      * @throws Exception
    67.      */
    68.     private static PublicKey loadPublicKeyFromString(String algorithm, String keyString) throws Exception {
    69.         // 进行Base64解码
    70.         byte[] decode = Base64.decode(keyString);
    71.         // 获取密钥工厂
    72.         KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
    73.         // 构建密钥规范
    74.         X509EncodedKeySpec keyspec = new X509EncodedKeySpec(decode);
    75.         // 获取公钥
    76.         return keyFactory.generatePublic(keyspec);
    78.     }
    80.     /**
    81.      * 从文件中加载私钥
    82.      *
    83.      * @param algorithm : 算法
    84.      * @param filePath  : 文件路径
    85.      * @return : 私钥
    86.      * @throws Exception
    87.      */
    88.     private static PrivateKey loadPrivateKeyFromFile(String algorithm, String filePath) throws Exception {
    89.         // 将文件内容转为字符串
    90.         String keyString = FileUtils.readFileToString(new File(filePath), Charset.forName("UTF-8"));
    91.         return loadPrivateKeyFromString(algorithm, keyString);
    93.     }
    95.     /**
    96.      * 从字符串中加载私钥
    97.      *
    98.      * @param algorithm : 算法
    99.      * @param keyString : 私钥字符串
    100.      * @return : 私钥
    101.      * @throws Exception
    102.      */
    103.     private static PrivateKey loadPrivateKeyFromString(String algorithm, String keyString) throws Exception {
    104.         // 进行Base64解码
    105.         byte[] decode = Base64.decode(keyString);
    106.         // 获取密钥工厂
    107.         KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
    108.         // 构建密钥规范
    109.         PKCS8EncodedKeySpec keyspec = new PKCS8EncodedKeySpec(decode);
    110.         // 生成私钥
    111.         return keyFactory.generatePrivate(keyspec);
    113.     }
    115.     /**
    116.      * 使用密钥加密数据
    117.      *
    118.      * @param algorithm      : 算法
    119.      * @param input          : 原文
    120.      * @param key            : 密钥
    121.      * @param maxEncryptSize : 最大加密长度(需要根据实际情况进行调整)
    122.      * @return : 密文
    123.      * @throws Exception
    124.      */
    125.     private static String encrypt(String algorithm, String input, Key key, int maxEncryptSize) throws Exception {
    126.         // 获取Cipher对象
    127.         Cipher cipher = Cipher.getInstance(algorithm);
    128.         // 初始化模式(加密)和密钥
    129.         cipher.init(Cipher.ENCRYPT_MODE, key);
    130.         // 将原文转为byte数组
    131.         byte[] data = input.getBytes();
    132.         // 总数据长度
    133.         int total = data.length;
    134.         // 输出流
    135.         ByteArrayOutputStream baos = new ByteArrayOutputStream();
    136.         decodeByte(maxEncryptSize, cipher, data, total, baos);
    137.         // 对密文进行Base64编码
    138.         return Base64.encode(baos.toByteArray());
    140.     }
    142.     /**
    143.      * 解密数据
    144.      *
    145.      * @param algorithm      : 算法
    146.      * @param encrypted      : 密文
    147.      * @param key            : 密钥
    148.      * @param maxDecryptSize : 最大解密长度(需要根据实际情况进行调整)
    149.      * @return : 原文
    150.      * @throws Exception
    151.      */
    152.     private static String decrypt(String algorithm, String encrypted, Key key, int maxDecryptSize) throws Exception {
    153.         // 获取Cipher对象
    154.         Cipher cipher = Cipher.getInstance(algorithm);
    155.         // 初始化模式(解密)和密钥
    156.         cipher.init(Cipher.DECRYPT_MODE, key);
    157.         // 由于密文进行了Base64编码, 在这里需要进行解码
    158.         byte[] data = Base64.decode(encrypted);
    159.         // 总数据长度
    160.         int total = data.length;
    161.         // 输出流
    162.         ByteArrayOutputStream baos = new ByteArrayOutputStream();
    164.         decodeByte(maxDecryptSize, cipher, data, total, baos);
    165.         // 输出原文
    166.         return baos.toString();
    168.     }
    170.     /**
    171.      * 分段处理数据
    172.      *
    173.      * @param maxSize : 最大处理能力
    174.      * @param cipher  : Cipher对象
    175.      * @param data    : 要处理的byte数组
    176.      * @param total   : 总数据长度
    177.      * @param baos    : 输出流
    178.      * @throws Exception
    179.      */
    180.     private static void decodeByte(int maxSize, Cipher cipher, byte[] data, int total, ByteArrayOutputStream baos) throws Exception {
    181.         // 偏移量
    182.         int offset = 0;
    183.         // 缓冲区
    184.         byte[] buffer;
    185.         // 如果数据没有处理完, 就一直继续
    186.         while (total - offset > 0) {
    187.             // 如果剩余的数据 >= 最大处理能力, 就按照最大处理能力来加密数据
    188.             if (total - offset >= maxSize) {
    189.                 // 加密数据
    190.                 buffer = cipher.doFinal(data, offset, maxSize);
    191.                 // 偏移量向右侧偏移最大数据能力个
    192.                 offset += maxSize;
    193.             } else {
    194.                 // 如果剩余的数据 < 最大处理能力, 就按照剩余的个数来加密数据
    195.                 buffer = cipher.doFinal(data, offset, total - offset);
    196.                 // 偏移量设置为总数据长度, 这样可以跳出循环
    197.                 offset = total;
    198.             }
    199.             // 向输出流写入数据
    200.             baos.write(buffer);
    201.         }
    202.     }
    203. }