任何一个安全的系统里，密码都是不允许明文传输的，一般传输到后台的密码都是经过加密，再由后台解密进行校验的，传统的加密方式就是通过RSA加密

RSA算法概述

我们看看加密算法的历史

对称加密算法

在1976年以前，所有的加密方法都是同一种模式 对称加密算法(Symmetric-key algorithm)
其特点就是如果甲传了一串密文给乙，那么乙必须要知道甲的加密规则才能解密。否则无法解密，这样就导致了加密算法的泄露，影响了系统安全性。

非对称加密算法

1976年，两位美国计算机学家Whitfield Diffie 和 Martin Hellman，提出了一种崭新构思，可以在不直接传递密钥的情况下，完成解密。这被称为“Diffie-Hellman密钥交换算法”。

  • （1）甲要传密信给乙，乙先根据某种算法得出本次与甲通信的公钥与私钥
  • （2）乙将公钥传给甲（公钥可以让任何人知道，即使泄露也没有任何关系）
  • （3）甲使用乙传给的公钥加密要发送的信息原文m，发送给乙加密后的密文c
  • （4）乙使用自己的私钥解密密文c，得到信息原文m

如果公钥加密的信息只有私钥解得开，那么只要私钥不泄漏，通信就是安全的。
简而言之，就是接收方只需要发布公钥，以及特定的算法，就可以实现数据安全。

RSA算法

1977年，三位数学家Rivest、Shamir 和 Adleman 设计了一种算法，可以实现非对称加密。这种算法用他们三个人的名字命名，叫做RSA算法。
这种算法非常可靠，密钥越长，它就越难破解。根据已经披露的文献，目前被破解的最长RSA密钥是768个二进制位。也就是说，长度超过768位的密钥，还无法破解（至少没人公开宣布）。因此可以认为，1024位的RSA密钥基本安全，2048位的密钥极其安全。

java RSA算法实现

  2. import org.apache.commons.codec.binary.Base64;
  4. import javax.crypto.BadPaddingException;
  5. import javax.crypto.Cipher;
  6. import javax.crypto.IllegalBlockSizeException;
  7. import java.io.ByteArrayOutputStream;
  8. import java.io.IOException;
  9. import java.security.*;
  10. import java.security.interfaces.RSAPrivateKey;
  11. import java.security.interfaces.RSAPublicKey;
  12. import java.security.spec.PKCS8EncodedKeySpec;
  13. import java.security.spec.X509EncodedKeySpec;
  14. import java.util.HashMap;
  15. import java.util.Map;
  17. /**
  18.  *
  19.  * @date 2019/7/31 13:48
  20.  */
  21. public class RSAUtils {
  23.     /**
  24.      * 加密算法RSA
  25.      */
  26.     public static final String KEY_ALGORITHM = "RSA";
  27.     /**
  28.      * 签名算法
  29.      */
  30.     public static final String SIGNATURE_ALGORITHM = "MD5withRSA";
  31.     /**
  32.      * 获取公钥的key
  33.      */
  34.     private static final String PUBLIC_KEY = "RSAPublicKey";
  35.     /**
  36.      * 获取私钥的key
  37.      */
  38.     private static final String PRIVATE_KEY = "RSAPrivateKey";
  39.     /**
  40.      * RSA最大加密明文大小
  41.      */
  42.     private static final int MAX_ENCRYPT_BLOCK = 117;
  43.     /**
  44.      * RSA最大解密密文大小
  45.      */
  46.     private static final int MAX_DECRYPT_BLOCK = 128;
  47.     /**
  48.      * RSA 位数 如果采用2048 上面最大加密和最大解密则须填写: 245 256
  49.      */
  50.     private static final int INITIALIZE_LENGTH = 1024;
  52.     /**
  53.      * 私钥
  54.      */
  55.     private static final String privateKey = "";
  57.     /**
  58.      * 生成密钥对(公钥和私钥)
  59.      *
  60.      * @return
  61.      * @throws Exception
  62.      */
  63.     public static Map<String, Object> genKeyPair() throws Exception {
  64.         KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
  65.         keyPairGen.initialize(INITIALIZE_LENGTH);
  66.         KeyPair keyPair = keyPairGen.generateKeyPair();
  67.         RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
  68.         RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
  69.         Map<String, Object> keyMap = new HashMap<String, Object>(2);
  70.         keyMap.put(PUBLIC_KEY, publicKey);
  71.         keyMap.put(PRIVATE_KEY, privateKey);
  72.         return keyMap;
  73.     }
  75.     /** */
  76.     /**
  77.      * 用私钥对信息生成数字签名
  78.      *
  79.      * @param data       已加密数据
  80.      * @return
  81.      * @throws Exception
  82.      */
  83.     public static String sign(byte[] data) throws Exception {
  84.         byte[] keyBytes = Base64.decodeBase64(privateKey);
  85.         PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
  86.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
  87.         PrivateKey privateK = keyFactory.generatePrivate(pkcs8KeySpec);
  88.         Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
  89.         signature.initSign(privateK);
  90.         signature.update(data);
  91.         return Base64.encodeBase64String(signature.sign());
  92.     }
  93.     /**
  94.      * 校验数字签名
  95.      *
  96.      * @param data      已加密数据
  97.      * @param publicKey 公钥(BASE64编码)
  98.      * @param sign      数字签名
  99.      * @return
  100.      * @throws Exception
  101.      */
  102.     public static boolean verify(byte[] data, String publicKey, String sign) throws Exception {
  103.         byte[] keyBytes = Base64.decodeBase64(publicKey);
  104.         X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
  105.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
  106.         PublicKey publicK = keyFactory.generatePublic(keySpec);
  107.         Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
  108.         signature.initVerify(publicK);
  109.         signature.update(data);
  110.         return signature.verify(Base64.decodeBase64(sign));
  111.     }
  113.     /**
  114.      * <p>
  115.      * 私钥解密
  116.      *
  117.      * @param encryptedData 已加密数据
  118.      * @return
  119.      * @throws Exception
  120.      */
  121.     private static byte[] decryptByPrivateKey(byte[] encryptedData) throws Exception {
  122.         byte[] keyBytes = Base64.decodeBase64(privateKey);
  123.         PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
  124.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
  125.         Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
  126.         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
  127.         return getBytes(encryptedData, privateK, cipher, Cipher.DECRYPT_MODE, MAX_DECRYPT_BLOCK);
  128.     }
  129.     /**
  130.      * 公钥解密
  131.      *
  132.      * @param encryptedData 已加密数据
  133.      * @param publicKey     公钥(BASE64编码)
  134.      * @return
  135.      * @throws Exception
  136.      */
  137.     public static byte[] decryptByPublicKey(byte[] encryptedData, String publicKey) throws Exception {
  138.         byte[] keyBytes = Base64.decodeBase64(publicKey);
  139.         X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
  140.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
  141.         Key publicK = keyFactory.generatePublic(x509KeySpec);
  142.         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
  143.         return getBytes(encryptedData, publicK, cipher, Cipher.DECRYPT_MODE, MAX_DECRYPT_BLOCK);
  144.     }
  146.     /**
  147.      * 公钥加密
  148.      *
  149.      * @param data      源数据
  150.      * @param publicKey 公钥(BASE64编码)
  151.      * @return
  152.      * @throws Exception
  153.      */
  154.     private static byte[] encryptByPublicKey(byte[] data, String publicKey) throws Exception {
  155.         byte[] keyBytes = Base64.decodeBase64(publicKey);
  156.         X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
  157.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
  158.         Key publicK = keyFactory.generatePublic(x509KeySpec);
  159.         // 对数据加密
  160.         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
  161.         return getBytes(data, publicK, cipher, Cipher.ENCRYPT_MODE, MAX_ENCRYPT_BLOCK);
  162.     }
  164.     /**
  165.      * 私钥加密
  166.      *
  167.      * @param data 源数据
  168.      * @return
  169.      * @throws Exception
  170.      */
  171.     public static byte[] encryptByPrivateKey(byte[] data) throws Exception {
  172.         byte[] keyBytes = Base64.decodeBase64(privateKey);
  173.         PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
  174.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
  175.         Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
  176.         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
  177.         return getBytes(data, privateK, cipher, Cipher.ENCRYPT_MODE, MAX_ENCRYPT_BLOCK);
  178.     }
  180.     private static byte[] getBytes(byte[] data, Key privateK, Cipher cipher, int encryptMode, int maxEncryptBlock)
  181.             throws InvalidKeyException, IllegalBlockSizeException, BadPaddingException, IOException {
  182.         cipher.init(encryptMode, privateK);
  183.         int inputLen = data.length;
  184.         ByteArrayOutputStream out = new ByteArrayOutputStream();
  185.         int offSet = 0;
  186.         byte[] cache;
  187.         int i = 0;
  188.         // 对数据分段加密
  189.         while (inputLen - offSet > 0) {
  190.             if (inputLen - offSet > maxEncryptBlock) {
  191.                 cache = cipher.doFinal(data, offSet, maxEncryptBlock);
  192.             } else {
  193.                 cache = cipher.doFinal(data, offSet, inputLen - offSet);
  194.             }
  195.             out.write(cache, 0, cache.length);
  196.             i++;
  197.             offSet = i * maxEncryptBlock;
  198.         }
  199.         byte[] encryptedData = out.toByteArray();
  200.         out.close();
  201.         return encryptedData;
  202.     }
  204.     /**
  205.      * 获取私钥
  206.      *
  207.      * @param keyMap 密钥对
  208.      * @return
  209.      * @throws Exception
  210.      */
  211.     public static String getPrivateKey(Map<String, Object> keyMap) throws Exception {
  212.         Key key = (Key) keyMap.get(PRIVATE_KEY);
  213.         return Base64.encodeBase64String(key.getEncoded());
  214.     }
  216.     /**
  217.      * 获取公钥
  218.      *
  219.      * @param keyMap 密钥对
  220.      * @return
  221.      * @throws Exception
  222.      */
  223.     public static String getPublicKey(Map<String, Object> keyMap) throws Exception {
  224.         Key key = (Key) keyMap.get(PUBLIC_KEY);
  225.         return Base64.encodeBase64String(key.getEncoded());
  226.     }
  228.     /**
  229.      * java端公钥加密
  230.      */
  231.     public static String encryptedDataOnJava(String data, String publicKey) {
  232.         try {
  233.             data = Base64.encodeBase64String(encryptByPublicKey(data.getBytes(), publicKey));
  234.         } catch (Exception e) {
  235.             e.printStackTrace();
  236.         }
  237.         return data;
  238.     }
  240.     /**
  241.      * java端私钥解密
  242.      */
  243.     public static String decryptDataOnJava(String data){
  244.         String temp = "";
  245.         byte[] rs = Base64.decodeBase64(data);
  246.         try {
  247.             temp = new String(decryptByPrivateKey(rs), "UTF-8");
  248.         } catch (Exception e) {
  249.             return null;
  250.         }
  251.         return temp;
  252.     }
  254. }
  1. 服务器通过 genKeyPair() 方法获得公钥、私钥。
  2. 将公钥发布给通信者（例如前端界面）
  3. 通信者获取公钥用同样的RSA算法加密数据。
  4. 服务器通过私钥进行数据解密

JavaScript RSA算法

  1. 可以通过引入外部RSA算法JS，来实现公钥加密 ```html

```

  1. 如果怕有外网限制，则使用本地文件jsencrypt.min.js 用法是一样的。