业务场景

在软件产品或者源码发布后，防止产品或者源码的外流导致核心竞争力被破解，直接影响商业价值，如何对产品进行加密，对产品的保护非常的重要。
1、办公软件-下载安装后如果没有进行授权，可以无限制的复制，导致产品被滥用，资金流失。
2、源码被窃取，通过源码解读，去除加密授权的拦截或者过滤功能，导致源码流失，资金损失，核心产品外泄。
如果去管控呢？
方法一、只对外发布产品安装包或者产品运行包，不提供核心源码，如果非要提供源码，也要控制核心工具类、验证类是jar包的形式使用，而非全部代码。
方法二、增加额外的验证机制，当发现拦截器或过滤器没有相应时候，采取代码破坏机制，动态删除一些核心的配置文件，并且将破解人的远程IP，机器码，授权源码信息发送给管理端。
方法三、代码混淆，源代码保护，代码逻辑混淆，代码加密，提高代码阅读成本
所有的加密、混淆、机制管控都是操作产品或者源码被泄露的手段，但是任何的手段都可以被破解，所以在实际过程中，除了增加手段之外还要结合其他的方式进行关联，比如签订合同、软著申请等等。

产品和源码认证授权加密

产品或者源码的认证加密，我们采用RSA非对称加密进行管理。

RSA非对称加密

什么是rsa非对称加密

一般场景 服务端和移动端 数据传输加密，用AES对称加密，同一个秘钥，当一端被获取后，数据都将被获取。
对称加密算法在加密和解密时使用的是同一个秘钥；而非对称加密算法需要两个密钥来进行加密和解密，这两个秘钥是公开密钥（public key，简称公钥）和私有密钥（private key，简称私钥）。
服务端-公钥加密 移动端-私钥解密。
与对称加密算法不同，非对称加密算法需要两个密钥：公开密钥（publickey）和私有密钥（privatekey）。公开密钥与私有密钥是一对，如果用公开密钥对数据进行加密，只有用对应的私有密钥才能解密；如果用私有密钥对数据进行加密，那么只有用对应的公开密钥才能解密。因为加密和解密使用的是两个不同的密钥，所以这种算法叫做非对称加密算法。
springboot Rsa非对称加密实现-产品和源码认证授权加密 - 图2

非对称加密的优缺点

非对称加密与对称加密相比，其安全性更好：对称加密的通信双方使用相同的秘钥，如果一方的秘钥遭泄露，那么整个通信就会被破解。而非对称加密使用一对秘钥，一个用来加密，一个用来解密，而且公钥是公开的，秘钥是自己保存的，不需要像对称加密那样在通信之前要先同步秘钥。
非对称加密的缺点是加密和解密花费时间长、速度慢，只适合对少量数据进行加密。

RSA加解密工具类

  1. package com.qingfeng.util;
  3. import java.io.ByteArrayOutputStream;
  4. import java.security.Key;
  5. import java.security.KeyFactory;
  6. import java.security.KeyPair;
  7. import java.security.KeyPairGenerator;
  8. import java.security.PrivateKey;
  9. import java.security.PublicKey;
  10. import java.security.Signature;
  11. import java.security.interfaces.RSAPrivateKey;
  12. import java.security.interfaces.RSAPublicKey;
  13. import java.security.spec.PKCS8EncodedKeySpec;
  14. import java.security.spec.X509EncodedKeySpec;
  15. import java.util.HashMap;
  16. import java.util.Map;
  18. import javax.crypto.Cipher;
  20. import org.apache.commons.codec.binary.Base64;
  22. /**
  23.  * <p>
  24.  *  rsa 加密工具
  25.  */
  26. public class RSAUtils {
  28.     /**
  29.      * 加密算法RSA
  30.      */
  31.     public static final String KEY_ALGORITHM = "RSA";
  33.     /**
  34.      * 签名算法
  35.      */
  36.     public static final String SIGNATURE_ALGORITHM = "MD5withRSA";
  38.     /**
  39.      * 获取公钥的key
  40.      */
  41.     private static final String PUBLIC_KEY = "RSAPublicKey";
  43.     /**
  44.      * 获取私钥的key
  45.      */
  46.     private static final String PRIVATE_KEY = "RSAPrivateKey";
  48.     /**
  49.      * RSA最大加密明文大小
  50.      */
  51.     private static final int MAX_ENCRYPT_BLOCK = 117;
  53.     /**
  54.      * RSA最大解密密文大小
  55.      */
  56.     private static final int MAX_DECRYPT_BLOCK = 128;
  58.     /**
  59.      * <p>
  60.      * 生成密钥对(公钥和私钥)
  61.      * </p>
  62.      *
  63.      * @return
  64.      * @throws Exception
  65.      */
  66.     public static Map<String, Object> genKeyPair() throws Exception {
  67.         KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
  68.         keyPairGen.initialize(1024);
  69.         KeyPair keyPair = keyPairGen.generateKeyPair();
  70.         RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
  71.         RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
  72.         Map<String, Object> keyMap = new HashMap<String, Object>(2);
  73.         keyMap.put(PUBLIC_KEY, publicKey);
  74.         keyMap.put(PRIVATE_KEY, privateKey);
  75.         return keyMap;
  76.     }
  78.     /**
  79.      * <p>
  80.      * 用私钥对信息生成数字签名
  81.      * </p>
  82.      *
  83.      * @param data 已加密数据
  84.      * @param privateKey 私钥(BASE64编码)
  85.      *
  86.      * @return
  87.      * @throws Exception
  88.      */
  89.     public static String sign(byte[] data, String privateKey) throws Exception {
  90.         byte[] keyBytes = decode(privateKey);
  91.         PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
  92.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
  93.         PrivateKey privateK = keyFactory.generatePrivate(pkcs8KeySpec);
  94.         Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
  95.         signature.initSign(privateK);
  96.         signature.update(data);
  97.         return encode(signature.sign());
  98.     }
  100.     /**
  101.      * <p>
  102.      * 校验数字签名
  103.      * </p>
  104.      *
  105.      * @param data 已加密数据
  106.      * @param publicKey 公钥(BASE64编码)
  107.      * @param sign 数字签名
  108.      *
  109.      * @return
  110.      * @throws Exception
  111.      *
  112.      */
  113.     public static boolean verify(byte[] data, String publicKey, String sign)
  114.             throws Exception {
  115.         byte[] keyBytes = decode(publicKey);
  116.         X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
  117.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
  118.         PublicKey publicK = keyFactory.generatePublic(keySpec);
  119.         Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
  120.         signature.initVerify(publicK);
  121.         signature.update(data);
  122.         return signature.verify(decode(sign));
  123.     }
  125.     /**
  126.      * <P>
  127.      * 私钥解密
  128.      * </p>
  129.      *
  130.      * @param encryptedData 已加密数据
  131.      * @param privateKey 私钥(BASE64编码)
  132.      * @return
  133.      * @throws Exception
  134.      */
  135.     public static byte[] decryptByPrivateKey(byte[] encryptedData, String privateKey)
  136.             throws Exception {
  137.         byte[] keyBytes = decode(privateKey);
  138.         PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
  139.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
  140.         Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
  141.         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
  142.         cipher.init(Cipher.DECRYPT_MODE, privateK);
  143.         int inputLen = encryptedData.length;
  144.         ByteArrayOutputStream out = new ByteArrayOutputStream();
  145.         int offSet = 0;
  146.         byte[] cache;
  147.         int i = 0;
  148.         // 对数据分段解密
  149.         while (inputLen - offSet > 0) {
  150.             if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
  151.                 cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
  152.             } else {
  153.                 cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
  154.             }
  155.             out.write(cache, 0, cache.length);
  156.             i++;
  157.             offSet = i * MAX_DECRYPT_BLOCK;
  158.         }
  159.         byte[] decryptedData = out.toByteArray();
  160.         out.close();
  161.         return decryptedData;
  162.     }
  164.     /**
  165.      * <p>
  166.      * 公钥解密
  167.      * </p>
  168.      *
  169.      * @param encryptedData 已加密数据
  170.      * @param publicKey 公钥(BASE64编码)
  171.      * @return
  172.      * @throws Exception
  173.      */
  174.     public static byte[] decryptByPublicKey(byte[] encryptedData, String publicKey)
  175.             throws Exception {
  176.         byte[] keyBytes = decode(publicKey);
  177.         X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
  178.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
  179.         Key publicK = keyFactory.generatePublic(x509KeySpec);
  180.         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
  181.         cipher.init(Cipher.DECRYPT_MODE, publicK);
  182.         int inputLen = encryptedData.length;
  183.         ByteArrayOutputStream out = new ByteArrayOutputStream();
  184.         int offSet = 0;
  185.         byte[] cache;
  186.         int i = 0;
  187.         // 对数据分段解密
  188.         while (inputLen - offSet > 0) {
  189.             if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
  190.                 cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
  191.             } else {
  192.                 cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
  193.             }
  194.             out.write(cache, 0, cache.length);
  195.             i++;
  196.             offSet = i * MAX_DECRYPT_BLOCK;
  197.         }
  198.         byte[] decryptedData = out.toByteArray();
  199.         out.close();
  200.         return decryptedData;
  201.     }
  203.     /**
  204.      * <p>
  205.      * 公钥加密
  206.      * </p>
  207.      *
  208.      * @param data 源数据
  209.      * @param publicKey 公钥(BASE64编码)
  210.      * @return
  211.      * @throws Exception
  212.      */
  213.     public static byte[] encryptByPublicKey(byte[] data, String publicKey)
  214.             throws Exception {
  215.         byte[] keyBytes = decode(publicKey);
  216.         X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
  217.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
  218.         Key publicK = keyFactory.generatePublic(x509KeySpec);
  219.         // 对数据加密
  220.         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
  221.         cipher.init(Cipher.ENCRYPT_MODE, publicK);
  222.         int inputLen = data.length;
  223.         ByteArrayOutputStream out = new ByteArrayOutputStream();
  224.         int offSet = 0;
  225.         byte[] cache;
  226.         int i = 0;
  227.         // 对数据分段加密
  228.         while (inputLen - offSet > 0) {
  229.             if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
  230.                 cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
  231.             } else {
  232.                 cache = cipher.doFinal(data, offSet, inputLen - offSet);
  233.             }
  234.             out.write(cache, 0, cache.length);
  235.             i++;
  236.             offSet = i * MAX_ENCRYPT_BLOCK;
  237.         }
  238.         byte[] encryptedData = out.toByteArray();
  239.         out.close();
  240.         return encryptedData;
  241.     }
  243.     /**
  244.      * <p>
  245.      * 私钥加密
  246.      * </p>
  247.      *
  248.      * @param data 源数据
  249.      * @param privateKey 私钥(BASE64编码)
  250.      * @return
  251.      * @throws Exception
  252.      */
  253.     public static byte[] encryptByPrivateKey(byte[] data, String privateKey)
  254.             throws Exception {
  255.         byte[] keyBytes =decode(privateKey);
  256.         PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
  257.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
  258.         Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
  259.         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
  260.         cipher.init(Cipher.ENCRYPT_MODE, privateK);
  261.         int inputLen = data.length;
  262.         ByteArrayOutputStream out = new ByteArrayOutputStream();
  263.         int offSet = 0;
  264.         byte[] cache;
  265.         int i = 0;
  266.         // 对数据分段加密
  267.         while (inputLen - offSet > 0) {
  268.             if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
  269.                 cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
  270.             } else {
  271.                 cache = cipher.doFinal(data, offSet, inputLen - offSet);
  272.             }
  273.             out.write(cache, 0, cache.length);
  274.             i++;
  275.             offSet = i * MAX_ENCRYPT_BLOCK;
  276.         }
  277.         byte[] encryptedData = out.toByteArray();
  278.         out.close();
  279.         return encryptedData;
  280.     }
  282.     /**
  283.      * <p>
  284.      * 获取私钥
  285.      * </p>
  286.      *
  287.      * @param keyMap 密钥对
  288.      * @return
  289.      * @throws Exception
  290.      */
  291.     public static String getPrivateKey(Map<String, Object> keyMap)
  292.             throws Exception {
  293.         Key key = (Key) keyMap.get(PRIVATE_KEY);
  294.         return encode(key.getEncoded());
  295.     }
  297.     /**
  298.      * <p>
  299.      * 获取公钥
  300.      * </p>
  301.      *
  302.      * @param keyMap 密钥对
  303.      * @return
  304.      * @throws Exception
  305.      */
  306.     public static String getPublicKey(Map<String, Object> keyMap)
  307.             throws Exception {
  308.         Key key = (Key) keyMap.get(PUBLIC_KEY);
  309.         return encode(key.getEncoded());
  310.     }
  312.     /**
  313.      * base64 加密
  314.      * @param bytes
  315.      * @return
  316.      * @throws Exception
  317.      */
  318.     public static String encode(byte[] bytes) throws Exception {
  319.         return new String(Base64.encodeBase64(bytes));
  320.     }
  321.     /**
  322.      * base64 解密
  323.      * @param base64
  324.      * @return
  325.      * @throws Exception
  326.      */
  327.     public static byte[] decode(String base64) throws Exception {
  328.         return Base64.decodeBase64(base64.getBytes());
  329.     }
  331.     /**
  332.      * @Description: 解密
  333.      * @Param: [data, privateKey]
  334.      * @return: java.lang.String
  335.      * @Author: anxingtao
  336.      * @Date: 2019-3-13 11:06
  337.      */
  338.     public static String decrypt(String data, String privateKey) throws Exception {
  339.         byte[] pubdata = decryptByPrivateKey(decode(data), privateKey);
  340.         return new String(pubdata, "UTF-8");
  341.     }
  343.     /**
  344.      * @Description: 加密
  345.      * @Param: [data, publicKey]
  346.      * @return: java.lang.String
  347.      * @Author: anxingtao
  348.      * @Date: 2019-3-13 11:10
  349.      */
  350.     public static String encrypt(String data, String publicKey) throws Exception {
  351.         byte[] pubdata = encryptByPublicKey(data.getBytes("UTF-8"), publicKey);
  352.         String outString = new String(encode(pubdata));
  353.         return outString;
  354.     }
  356.     /**
  357.      * @title encrypriva
  358.      * @description 私钥加密
  359.      * @author Administrator
  360.      * @updateTime 2021/8/11 16:31
  361.      */
  362.     public static String encrypk(String data, String privateKey) throws Exception {
  363.         byte[] resdata = encryptByPrivateKey(data.getBytes("UTF-8"), privateKey);
  364.         String outString = new String(encode(resdata));
  365.         return outString;
  366.     }
  368.     /**
  369.      * @title decrypk
  370.      * @description 公钥解密
  371.      * @author Administrator
  372.      * @updateTime 2021/8/11 16:32
  373.      */
  374.     public static String decrypk(String data, String publicKey) throws Exception {
  375.         byte[] resdata = decryptByPublicKey(decode(data), publicKey);
  376.         return new String(resdata, "UTF-8");
  377.     }
  380.     public static void main(String[] args) throws Exception {
  381. //        String privateKey = "MIICdwIBADANBgkqhkiG9w0BAQEFAASCAmEwggJdAgEAAoGBALbGpPkikVf51rzHHr5rCmtIjpsq9Pked0W5xu5Khf4fQEl7utYahfC3dleFaCyLkD39Q1PpyOrQm7YQPSxkHR7Bn/w/CA93EYNKXG1cAZjDr/ZJAd6xUY2K4GkriWB9v4OeCTThkKwfharJJW270No5VT49ktKAHKkug/WnCUN7AgMBAAECgYEAlxPNK20qTFjj6biBLg5WV2VrEtFIGl7XYdf0meUZqnr0bYkLX4we6GENPby05hUaTlL4gvT8MTPrcWss1XOPKQYRrSjLBZmmCiYe+SDxx0ZPmNN1db86X0ahQsNzxAVkTyIKKVW1SxwyvIOSN5H71yyBzZj/yG0qymj8H0hBVFkCQQDijlLZ9E7pGT/2HLitxEyi02kIjlsgLtjmk8NP8if5eCspmKXaw3xH2j3BLOGDGZUjeQGZcyOOHdGnNkbUVSdtAkEAzoe6ugzr63r70CwbWAEBQLRUfX4i8fiLazlCybhVAMEKjbKTdcAUFLfKNmharPHE/dlHLja/dReaLMKB7l69hwJABcM/AkI/m5hD0zvJysm6dU3RVyFf2gK3C65ogmkTcToIRweV+GmOiLlZZseAePg2ne9fBgsytVO22Hz98jq0RQJAGOyOX0eR7RAhdYTtI9izMwDQNXjUdMke4ii946QoNfgV8vW7D/nHMpzffWNolfhzYoMnMO+QeWwIwiATGBY83wJBAN5aLGltsuW/6ILvMTgciwdQlO3dTjzFXhbXURsyKWYF6QJnaeqNMVqr9F0lWXKQyuIu+mj5JRkZszOvS0jczNA=\n";
  382. //        String publicKey = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC2xqT5IpFX+da8xx6+awprSI6bKvT5HndFucbuSoX+H0BJe7rWGoXwt3ZXhWgsi5A9/UNT6cjq0Ju2ED0sZB0ewZ/8PwgPdxGDSlxtXAGYw6/2SQHesVGNiuBpK4lgfb+Dngk04ZCsH4WqySVtu9DaOVU+PZLSgBypLoP1pwlDewIDAQAB";
  383. //        String msg = "{\"dev_id\":\"868989034328943\",\"user_id\":\"\",\"team_id\":\"\"}";
  384. //        String msg = DateTimeUtil.getDate();
  385. //        String sm = RSAUtils.encrypt(msg,publicKey);
  386. //        System.out.println(sm);
  387. //        String str = "IGCJsmAEdYDle/WYAS4qd3hCp9TAZRz806Sm8p4KepJ2XuDaOnKh65homSgZJ88/pQs5rEm6Qmsg+8JqMgqjixD8jZhnToVriKzkhHe2UarS+sT8oUAvXrO98FwZv7GELgt4mCuitwxrREYq4QUtwI6Fc+SGdF0BjeKNUSWHifg=";
  388. //
  389. //
  390. //
  391. //        String s = RSAUtils.decrypt(sm,privateKey);
  392. //        System.out.println(s);
  394.         //生成密钥对(公钥和私钥)
  395.         Map map = RSAUtils.genKeyPair();
  396.         System.out.println("----------------公钥----------------");
  397.         System.out.println(RSAUtils.getPublicKey(map));
  398.         System.out.println("----------------私钥----------------");
  399.         System.out.println(RSAUtils.getPrivateKey(map));
  401. //        String str = RSAUtils.encrypk("我爱你中国",privateKey);
  402. //        System.out.println(str);
  403. //
  404. //        String res = RSAUtils.decrypk(str,publicKey);
  405. //        System.out.println(res);
  407. //        String content = "F2cgqkTN1DehdikNnKtt5t0p+HrOr4hwWrbf9MGmksWUQFwWzFPbwt1at7uXYp8mt88KiIHrD/yKe8pkdzuq2VMTyvObryIbVannBHtzrhjBd2FoRQpaorMWtFuv7MZY3WmuqhzdhXMXAx1pB/hmEToncvW3ZpEWp7N5ItO89H8=";
  408. //        String priKey = "MIICYQIBAAKBgQCijkoTGTel/S62WwUpXswc8m7Fdp+SY2ZMZKV8FeRD5QUi1mGYUHqmab7w/xN2vdNWI9sR9MPL4aO2IA57HD4HTGmidyCDmxl8QCRMSNwXroIP6mWpI5lHjajPth25n2gwsnYoAvrSfTnTkUAmoKUtQSg3/AZ9Rg8mf8NFY5AjGwIDAQABAoGBAJqS8W9NyHPn2DaBQNxBD5jrE1hj34NFT+6OuinPa1sAeSzSbMV4qdh6r53dADYmdcLwn41okZLbAmDaBBscUUZo/pIUPdGgU+P7RqpMtfwbq/RoleFpU2GWBErJ7/qKe6cfcEyuBhAMG8vLqtfA70P75vFAMoKhzWsUGtD5gQVZAkUAuRjD839QS/u17Xv6jWbcw0vxTD2UN/hyObyQORlX+LjxC5RCuYwkkWoXIGe94hzsyCoURc6RhakRM/LyqhCliTQ+PvcCPQDg0xUHm2qr8jfo1PTYf6Ks8Id9FZiqxD1VJh2OoRMSTCPo8O4PskbzictNu2siFLt0r3EKjCDP1jP0H/0CRFSsO5d8OiNINmU5PdjJoVvFtdCGqvMfuEEpPWChc1jYYYxGem+e6GuM+J9eVcLGMJswhK2aXX+jY7c8AD5D9zXYrFDpAj0Ap5OOXEIyy4FavRhmfCz+wyrxwoFjbv2gvaQQaeyTu5K3PXy/5UE783Ek8Yad/yQ26W2Ps43pMyF1TiS9AkQrfddTmrz7OZEfFtgaHuSj/8gbkGEdr7H8YIML/wZ1ozDkfxwsnzgclJXir/Qb2VjGOSzfUrlj2SaxgqIGfKI7DyEWeg==";
  409. //        System.out.println(priKey);
  410. //
  411. //        String priKey2 = "MIICewIBADANBgkqhkiG9w0BAQEFAASCAmUwggJhAgEAAoGBAKKOShMZN6X9LrZbBSlezBzybsV2n5JjZkxkpXwV5EPlBSLWYZhQeqZpvvD/E3a901Yj2xH0w8vho7YgDnscPgdMaaJ3IIObGXxAJExI3Beugg/qZakjmUeNqM+2HbmfaDCydigC+tJ9OdORQCagpS1BKDf8Bn1GDyZ/w0VjkCMbAgMBAAECgYEAmpLxb03Ic+fYNoFA3EEPmOsTWGPfg0VP7o66Kc9rWwB5LNJsxXip2Hqvnd0ANiZ1wvCfjWiRktsCYNoEGxxRRmj+khQ90aBT4/tGqky1/Bur9GiV4WlTYZYESsnv+op7px9wTK4GEAwby8uq18DvQ/vm8UAygqHNaxQa0PmBBVkCRQC5GMPzf1BL+7Xte/qNZtzDS/FMPZQ3+HI5vJA5GVf4uPELlEK5jCSRahcgZ73iHOzIKhRFzpGFqREz8vKqEKWJND4+9wI9AODTFQebaqvyN+jU9Nh/oqzwh30VmKrEPVUmHY6hExJMI+jw7g+yRvOJy027ayIUu3SvcQqMIM/WM/Qf/QJEVKw7l3w6I0g2ZTk92MmhW8W10Iaq8x+4QSk9YKFzWNhhjEZ6b57oa4z4n15VwsYwmzCErZpdf6NjtzwAPkP3NdisUOkCPQCnk45cQjLLgVq9GGZ8LP7DKvHCgWNu/aC9pBBp7JO7krc9fL/lQTvzcSTxhp3/JDbpbY+zjekzIXVOJL0CRCt911OavPs5kR8W2Boe5KP/yBuQYR2vsfxggwv/BnWjMOR/HCyfOByUleKv9BvZWMY5LN9SuWPZJrGCogZ8ojsPIRZ6";
  412. //
  413. //        System.out.println(RSAUtils.decrypt(content,priKey2));
  414.     }
  417. }

新增证书颁发模块

证书模块功能效果image.png

新增证书image.png
image.png

核心代码解析

  1. /**
  2.      * @title exportCert
  3.      * @description 导出证书
  4.      * @author Administrator
  5.      * @updateTime 2021/8/11 15:46
  6.      */
  7.     @RequiresPermissions("authCert:exportCert")
  8.     @RequestMapping(value = "/exportCert", method = RequestMethod.GET)
  9.     public void exportCert(HttpServletRequest request, HttpServletResponse response, HttpSession session) throws Exception {
  10.         PageData pd = new PageData(request);
  11.         PageData p = authCertService.findInfo(pd);
  12.         String content = p.get("title")+"#"+p.get("start_time")+"#"+p.get("end_time")+"#"+p.get("ip_address")+"#"+p.get("mac_address")+"#"+p.get("other_limit");
  13.         System.out.println(content);
  14.         System.out.println(commonConfig.getPublicKey());
  15.         String license = RSAUtils.encrypt(content,commonConfig.getPublicKey());
  16.         // 创建根节点
  17.         Element root = new Element("QingFeng");
  18.         // 为根节点设置属性
  19.         root.setAttribute("version", p.get("version_num").toString());
  20.         // 创建Document对象，并为其设置根节点
  21.         Document document = new Document(root);
  23.         Element title = new Element("Title");
  24.         Element sdate = new Element("SDate");
  25.         Element edate = new Element("EDate");
  26.         Element ip = new Element("IP");
  27.         Element mac = new Element("MAC");
  28.         Element olimit = new Element("OLimit");
  29.         Element licenseKeys = new Element("LicenseKeys");
  31.         title.addContent(p.get("title").toString());
  32.         sdate.addContent(p.get("start_time").toString());
  33.         edate.addContent(p.get("end_time").toString());
  34.         ip.addContent(p.get("ip_address")+"");
  35.         mac.addContent(p.get("mac_address")+"");
  36.         olimit.addContent(p.get("other_limit")+"");
  37.         licenseKeys.addContent(license);
  39.         root.addContent(title);
  40.         root.addContent(sdate);
  41.         root.addContent(edate);
  42.         root.addContent(ip);
  43.         root.addContent(mac);
  44.         root.addContent(olimit);
  45.         root.addContent(licenseKeys);
  46.         // 创建XMLOutputter对象
  47.         XMLOutputter outputter = new XMLOutputter();
  48.         //创建Format对象（自动缩进、换行）
  49.         Format format = Format.getPrettyFormat();
  50.         //为XMLOutputter设置Format对象
  51.         outputter.setFormat(format);
  52.         // 将Document转换成XML
  53.         String tempPath = "D:\\home\\template\\QingfengLicense.xml";
  54. //        String tempPath = session.getServletContext().getRealPath("/") + "/template/QingfengLicense.xml";
  55.         outputter.output(document, new FileOutputStream(new File(tempPath)));
  56. //        String toPath = session.getServletContext().getRealPath("/") + "/template/QingfengLicense.zip";
  57.         /** 测试压缩方法2  */
  58. //        List<File> fileList = new ArrayList<>();
  59. //        fileList.add(new File(tempPath));
  60. //        FileOutputStream fos2 = new FileOutputStream(new File(toPath));
  61. //        ZipUtils.toZip(fileList, fos2);
  62.         FileUtil.downFile(response, tempPath, "QingfengLicense.xml");
  63. //        File file = new File(toPath);
  64. //        file.delete();
  65. //        file.deleteOnExit();
  66.     }

证书下载

  1. public static void downFile(HttpServletResponse response, String filePath,
  2.                                 String filename) throws Exception {
  3.         File tempFile = new File(filePath);
  4.         System.out.println(tempFile.exists());
  5.         if (tempFile.exists()) {
  6.             response.reset();
  7.             response.setContentType("bin");//
  8.             filename = new String(filename.getBytes(), "ISO-8859-1");
  9.             response.addHeader("Content-Disposition", "attachment;filename="
  10.                     + filename);
  11.             FileInputStream fis = new FileInputStream(tempFile);
  12.             OutputStream os = response.getOutputStream();
  13.             byte[] bb = new byte[1024*8];
  14.             int i = 0;
  15.             while ((i = fis.read(bb)) > 0) {
  16.                 os.write(bb, 0, i);
  17.             }
  18.             os.close();
  19.             os.flush();
  20.             fis.close();
  21.         }
  22.     }

证书认证校验-项目启动

证书校验源码

  1. /**
  2.  * 继承Application接口后项目启动时会按照执行顺序执行run方法
  3.  * 通过设置Order的value来指定执行的顺序
  4.  */
  5. @Component
  6. @Order(value = 1)
  7. public class StartService implements ApplicationRunner {
  9.     @Autowired
  10.     private CommonConfig commonConfig;
  12.     @Override
  13.     public void run(ApplicationArguments applicationArguments) throws Exception {
  14.         ClassPathResource classPathResource = new ClassPathResource("config/QingfengLicense.xml");
  15. //        InputStream inputStream =classPathResource.getInputStream();
  16.         // 创建SAXReader对象
  17.         SAXReader reader = new SAXReader();
  18.         // 加载xml文件
  19.         Document dc= reader.read(classPathResource.getFile());
  20.         // 获取根节点
  21.         Element e = dc.getRootElement();
  22.         System.out.println(e);
  23.         // 获取迭代器
  24.         Iterator it = e.elementIterator();
  25.         // 遍历迭代器，获取根节点信息
  26.         PageData pd = new PageData();
  27.         while(it.hasNext()){
  28.             Element book = (Element) it.next();
  29.             pd.put(book.getName(),book.getStringValue());
  30.         }
  31.         String LicenseKeys = pd.get("LicenseKeys").toString();
  33.         String license = RSAUtils.decrypt(LicenseKeys,commonConfig.getPrivateKey());
  34.         if(Verify.verifyIsNull(license)){
  35.             throw new RuntimeException("正式认证失败。");
  36.         }else{
  37.             System.out.println(license);
  38.             String[] params = license.split("#", -1);
  39.             System.out.println(params.length);
  40.             String title = params[0];
  41.             String start_time = params[1];
  42.             String end_time = params[2];
  43.             String ip_address = params[3];
  44.             String mac_address = params[4];
  45.             String other_limit = params[5];
  47.             SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
  48.             Date startDate = sdf.parse(start_time);
  49.             Date endDate = sdf.parse(end_time);
  50.             if(startDate.after(DateTimeUtil.getDDate()) || endDate.before(DateTimeUtil.getDDate())){
  51.                 throw new RuntimeException("认证正式已失效，请重新授权。");
  52.             }
  53.             System.out.println(IpUtils.getIpAddress());
  54.             System.out.println(IpUtils.getMacAddress());
  55.             if(Verify.verifyIsNotNull(ip_address)){
  56.                 if(!ip_address.equals(IpUtils.getIpAddress())){
  57.                     throw new RuntimeException("授权IP无效，请重新授权。");
  58.                 }
  59.             }
  60.             if(Verify.verifyIsNotNull(mac_address)){
  61.                 if(!mac_address.equals(IpUtils.getMacAddress())){
  62.                     throw new RuntimeException("授权MAC无效，请重新授权。");
  63.                 }
  64.             }
  66.         }
  67. //        System.out.println("###############################项目启动成功###############################");
  68.     }
  69. }

ApplicationRunner接口功能说明

1、ApplicationRunner
是一个接口，常用于项目启动后，（也就是ApringApplication.run()执行结束），立马执行某些逻辑。
可用于项目的准备工作，比如加载配置文件，加载执行流，定时任务等等。
2、如何使用ApplicationRunner
可以有多个实例实现该接口，但是一般需要增加注解@Order来指定加载顺序
@Order(-1)优先于@Order(0)
@Order(1)优先于@Order(2)

  1. @Component
  2. @Order(2)
  3. public class QingfengRunner implements ApplicationRunner {
  4.     @Override
  5.     public void run(ApplicationArguments args) throws Exception {
  6.         System.out.println(args);
  7.         System.out.println("这个是测试ApplicationRunner接口");
  8.     }
  9. }

3、还有个接口，也可以实现和ApplicationRunner一样的功能
CommandLineRunner
CommandLineRunner接口的run方法接收的参数为String数组

  1. @Component
  2. @Order(value = 2)
  3. public class MyStartupRunner1 implements CommandLineRunner{
  4. @Override
  5. public void run(String... strings) throws Exception {
  6.     System.out.println(">>>>>>>>>>>>>>>服务启动执行，执行加载数据等操作 MyStartupRunner1 order 2 <<<<<<<<<<<<<");
  7.     }
  8. }
  10. @Component
  11. @Order(value = 1)
  12. public class MyStartupRunner2 implements CommandLineRunner {
  13. @Override
  14. public void run(String... strings) throws Exception {
  15.     System.out.println(">>>>>>>>>>>>>>>服务启动执行，执行加载数据等操作 MyStartupRunner2 order 1 <<<<<<<<<<<<<");
  16.     }
  17. }

证书认证校验-过滤器

过滤器证书校验源码

  1. @Configuration
  2. public class WebFilterConfig {
  4.     @Bean
  5.     public FilterRegistrationBean filterDemo3Registration() {
  6.         FilterRegistrationBean registration = new FilterRegistrationBean();
  7.         registration.setFilter(WebUrlFilter());
  8.         registration.addUrlPatterns("/*");
  9.         registration.addInitParameter("paramName", "paramValue");
  10.         registration.setName("filterDemo3");
  11.         registration.setOrder(1);
  12.         return registration;
  13.     }
  16.     @Bean
  17.     public Filter WebUrlFilter() {
  18.         return new WebUrlFilter();
  19.     }
  21. }
  1. public class WebUrlFilter implements Filter {
  2.     private final Logger log = LoggerFactory.getLogger(getClass());
  4.    @Autowired
  5.    private CommonConfig commonConfig;
  7.     @Override
  8.     public void init(FilterConfig arg0) throws ServletException {
  9.         System.out.println("doFilter 1");
  10.     }
  12.     @SneakyThrows
  13.     @Override
  14.     public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain) throws IOException, ServletException {
  15. //        request.setAttribute("menuAuthParams","add,edit,del");
  16.         System.out.println("doFilter 2");
  18.         ClassPathResource classPathResource = new ClassPathResource("config/QingfengLicense.xml");
  19. //        InputStream inputStream =classPathResource.getInputStream();
  20.         // 创建SAXReader对象
  21.         SAXReader reader = new SAXReader();
  22.         // 加载xml文件
  23.         Document dc= reader.read(classPathResource.getFile());
  24.         // 获取根节点
  25.         Element e = dc.getRootElement();
  26.         System.out.println(e);
  27.         // 获取迭代器
  28.         Iterator it = e.elementIterator();
  29.         // 遍历迭代器，获取根节点信息
  30.         PageData pd = new PageData();
  31.         while(it.hasNext()){
  32.             Element book = (Element) it.next();
  33.             pd.put(book.getName(),book.getStringValue());
  34.         }
  35.         String LicenseKeys = pd.get("LicenseKeys").toString();
  37.         String license = RSAUtils.decrypt(LicenseKeys,commonConfig.getPrivateKey());
  38.         if(Verify.verifyIsNull(license)){
  39.             throw new RuntimeException("正式认证失败。");
  40.         }else{
  41.             System.out.println(license);
  42.             String[] params = license.split("#", -1);
  43.             System.out.println(params.length);
  44.             String title = params[0];
  45.             String start_time = params[1];
  46.             String end_time = params[2];
  47.             String ip_address = params[3];
  48.             String mac_address = params[4];
  49.             String other_limit = params[5];
  51.             SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
  52.             Date startDate = sdf.parse(start_time);
  53.             Date endDate = sdf.parse(end_time);
  54.             if(startDate.after(DateTimeUtil.getDDate()) || endDate.before(DateTimeUtil.getDDate())){
  55.                 throw new RuntimeException("认证正式已失效，请重新授权。");
  56.             }
  57.             System.out.println(IpUtils.getIpAddress());
  58.             System.out.println(IpUtils.getMacAddress());
  59.             if(Verify.verifyIsNotNull(ip_address)){
  60.                 if(!ip_address.equals(IpUtils.getIpAddress())){
  61.                     throw new RuntimeException("授权IP无效，请重新授权。");
  62.                 }
  63.             }
  64.             if(Verify.verifyIsNotNull(mac_address)){
  65.                 if(!mac_address.equals(IpUtils.getMacAddress())){
  66.                     throw new RuntimeException("授权MAC无效，请重新授权。");
  67.                 }
  68.             }
  70.         }
  71.         filterChain.doFilter(request, response);
  73.     }
  75.     @Override
  76.     public void destroy() {
  77.         System.out.println("doFilter 3");
  78.     }
  81. }

什么是过滤器

过滤器的概念

在讲Spring boot之前，我们先了解一下过滤器和拦截器。这两者在功能方面很类似，但是在具体技术实现方面，差距还是比较大的。在分析两者的区别之前，我们先理解一下AOP的概念，AOP不是一种具体的技术，而是一种编程思想。在面向对象编程的过程中，我们很容易通过继承、多态来解决纵向扩展。 但是对于横向的功能，比如，在所有的service方法中开启事务，或者统一记录日志等功能，面向对象的是无法解决的。所以AOP——面向切面编程其实是面向对象编程思想的一个补充。而我们今天讲的过滤器和拦截器都属于面向切面编程的具体实现。而两者的主要区别包括以下几个方面：
1、Filter是依赖于Servlet容器，属于Servlet规范的一部分，而拦截器则是独立存在的，可以在任何情况下使用。
2、Filter的执行由Servlet容器回调完成，而拦截器通常通过动态代理的方式来执行。
3、Filter的生命周期由Servlet容器管理，而拦截器则可以通过IoC容器来管理，因此可以通过注入等方式来获取其他Bean的实例，因此使用会更方便。

过滤器的使用场景

Java过滤器是处于客户端与服务器资源文件之间的一道过滤网，在访问资源文件之前，通过一系列的过滤器可以对请求进行修改、判断等，把不符合规则的请求在中途拦截或修改；也可以对响应进行过滤，拦截或修改响应。
image.png
如图，浏览器发出的请求先递交给第一个filter进行过滤，符合规则则放行，递交给filter链中的下一个过滤器进行过滤。过滤器在链中的顺序与它在web.xml中配置的顺序有关，配置在前的则位于链的前端。当请求通过了链中所有过滤器后就可以访问资源文件了，如果不能通过，则可能在中间某个过滤器中被处理掉。

在doFilter()方法中，chain.doFilter()前的一般是对request执行的过滤操作，chain.doFilter后面的代码一般是对response执行的操作。过滤链代码的执行顺序如下：
image.png
过滤器一般用于登录权限验证、资源访问权限控制、敏感词汇过滤、字符编码转换等等操作，便于代码重用，不必每个servlet中还要进行相应的操作。

代码混淆ProGuard

ProGuard简介

ProGuard是一个混淆代码的开源项目，它的主要作用是混淆代码，ProGuard还包括以下4个功能。

  1. 压缩(Shrink)：检测并移除代码中无用的类、字段、方法和特性（Attribute）。
  2. 优化(Optimize)：对字节码进行优化，移除无用的指令。
  3. 混淆(Obfuscate)：使用a，b，c，d这样简短而无意义的名称，对类、字段和方法进行重命名。
  4. 预检(Preveirfy)：在Java平台上对处理后的代码进行预检，确保加载的class文件是可执行的。

Proguard是一个Java类文件压缩器、优化器、混淆器、预校验器。压缩环节会检测以及移除没有用到的类、字段、方法以及属性。优化环节会分析以及优化方法的字节码。混淆环节会用无意义的短变量去重命名类、变量、方法。这些步骤让代码更精简，更高效，也更难被逆向（破解）。

Springboot整合ProGuard代码混淆

  1.  <!-- proguard混淆插件-->
  2.             <plugin>
  3.                 <groupId>com.github.wvengen</groupId>
  4.                 <artifactId>proguard-maven-plugin</artifactId>
  5.                 <version>2.2.0</version>
  6.                 <executions>
  7.                     <execution>
  8.                         <!-- 打包的时候开始混淆-->
  9.                         <phase>package</phase>
  10.                         <goals>
  11.                             <goal>proguard</goal>
  12.                         </goals>
  13.                     </execution>
  14.                 </executions>
  15.                 <configuration>
  16.                     <injar>${project.build.finalName}.jar</injar>
  17.                     <!--输出的jar-->
  18.                     <outjar>${project.build.finalName}.jar</outjar>
  19.                     <!-- 是否混淆-->
  20.                     <obfuscate>true</obfuscate>
  21.                     <options>
  22.                         <option>-target 1.8</option> <!--指定java版本号-->
  23.                         <option>-dontshrink</option> <!--默认开启，不做收缩（删除注释、未被引用代码）-->
  24.                         <option>-dontoptimize</option><!--默认是开启的，这里关闭字节码级别的优化-->
  25.                         <!-- 不路过非公用类文件及成员-->
  26.                         <option>-dontskipnonpubliclibraryclasses</option>
  27.                         <option>-dontskipnonpubliclibraryclassmembers</option>
  28.                         <!--不用大小写混合类名机制-->
  29.                         <option>-dontusemixedcaseclassnames</option>
  30.                         <!-- 优化时允许访问并修改有修饰符的类和类的成员 -->
  31.                         <option>-allowaccessmodification</option>
  32.                         <!-- 确定统一的混淆类的成员名称来增加混淆-->
  33.                         <option>-useuniqueclassmembernames</option>
  34.                         <!-- 不混淆所有包名-->
  35.                         <!--<option>-keeppackagenames</option>-->
  37.                         <option>-adaptclassstrings</option><!--混淆类名之后，对使用Class.forName('className')之类的地方进行相应替代-->
  38.                         <option>-ignorewarnings
  39.                         </option><!-- 忽略warn消息,如果提示org.apache.http.* 这个包里的类有问题，那么就加入下述代码：-keep class org.apache.http.** { *; }    -dontwarn org.apache.http.**-->
  40.                         <option>-keep class org.apache.logging.log4j.util.* { *; }</option>
  41.                         <option>-dontwarn org.apache.logging.log4j.util.**</option>
  42.                         <option>-keepattributes
  43.                             Exceptions,InnerClasses,Signature,Deprecated,SourceFile,LineNumberTable,*Annotation*,EnclosingMethod
  44.                         </option><!--对异常、注解信息在runtime予以保留，不然影响springboot启动-->
  45.                         <!--不混淆所有interface接口-->
  46.                         <!--                        <option>-keepnames interface **</option>-->
  47.                         <option>-keepclassmembers enum * { *; }</option><!--保留枚举成员及方法-->
  48.                         <option>-keepparameternames</option>
  49.                         <option>-keepclasseswithmembers public class * {
  50.                             public static void main(java.lang.String[]);}
  51.                         </option> <!--保留main方法的类及其方法名-->
  52.                         <!--忽略note消息，如果提示javax.annotation有问题，那麽就加入以下代码-->
  53.                         <option>-dontnote javax.annotation.**</option>
  54.                         <option>-dontnote sun.applet.**</option>
  55.                         <option>-dontnote sun.tools.jar.**</option>
  56.                         <option>-dontnote org.apache.commons.logging.**</option>
  57.                         <option>-dontnote javax.inject.**</option>
  58.                         <option>-dontnote org.aopalliance.intercept.**</option>
  59.                         <option>-dontnote org.aopalliance.aop.**</option>
  60.                         <option>-dontnote org.apache.logging.log4j.**</option>
  62.                         <!--  ##### 以下为需要根据项目情况修改 comment by 青锋  ##### -->
  63.                         <!--入口程序类不能混淆，混淆会导致springboot启动不了-->
  64.                         <option>-keep class com.qingfeng.Application</option>
  65.                         <option>-keep class com.qingfeng.framework.**.* {*;}</option>
  66.                         <option>-keep class com.qingfeng.quartz.**.* {*;}</option>
  67. <!--                        <option>-keep class com.qingfeng.system.entity.* {*;}</option>-->
  68. <!--                        <option>-keep class com.qingfeng.system.model.* {*;}</option>-->
  69. <!--                        <option>-keep class com.qingfeng.system.controller.* {*;}</option>-->
  70.                         <!--  ##### 以上为需要根据项目情况修改  comment by qingfeng ##### -->
  72.                         <option>-keep interface * extends * { *; }</option>
  73.                         <!--不混淆所有类,保存原始定义的注释-->
  74.                         <option>-keepclassmembers class * {
  75.                             @org.springframework.beans.factory.annotation.Autowired *;
  76.                             @org.springframework.beans.factory.annotation.Value *;
  77.                             }
  78.                         </option>
  79.                     </options>
  80.                     <libs>
  81.                         <!-- 添加依赖 java8-->
  82.                         <lib>${java.home}/lib/rt.jar</lib>
  83.                         <lib>${java.home}/lib/jce.jar</lib>
  84.                     </libs>
  85.                 </configuration>
  86.                 <dependencies>
  87.                     <!-- https://mvnrepository.com/artifact/net.sf.proguard/proguard-base -->
  88.                     <dependency>
  89.                         <groupId>net.sf.proguard</groupId>
  90.                         <artifactId>proguard-base</artifactId>
  91.                         <version>6.1.1</version>
  92.                     </dependency>
  93.                 </dependencies>
  94.             </plugin>
  96.             <!--Springboot repackage 打包-->
  97.             <plugin>
  98.                 <groupId>org.springframework.boot</groupId>
  99.                 <artifactId>spring-boot-maven-plugin</artifactId>
  100.                 <executions>
  101.                     <execution>
  102.                         <!-- spingboot 打包需要repackage否则不是可执行jar -->
  103.                         <goals>
  104.                             <goal>repackage</goal>
  105.                         </goals>
  106.                         <configuration>
  107.                             <mainClass>com.qingfeng.Application</mainClass>
  108.                         </configuration>
  109.                     </execution>
  110.                 </executions>
  111.             </plugin>

问题：
1.由于在混淆后代码a.class,b.class,c.class等方式，会导致springboot注入bean的时候报bean冲突，需要对生成bean策略进行修改，添加类：

  1. package com.qingfeng;
  3. import org.springframework.beans.factory.config.BeanDefinition;
  4. import org.springframework.beans.factory.support.BeanDefinitionRegistry;
  5. import org.springframework.context.annotation.AnnotationBeanNameGenerator;
  7. /**
  8.  * @author Administrator
  9.  * @version 1.0.0
  10.  * @ProjectName qingfengThymeleaf
  11.  * @Description sping下代码混淆后，不同包下的bean名相同会报bean冲突
  12.  * @createTime 2022年04月25日 22:59:00
  13.  */
  14. public class UniqueNameGenerator extends AnnotationBeanNameGenerator {
  15.     @Override
  16.     public String generateBeanName(BeanDefinition definition, BeanDefinitionRegistry registry) {
  17.         //全限定类名
  18.         String beanName = definition.getBeanClassName();
  19.         return beanName;
  20.     }
  21. }
  1. @ComponentScan(nameGenerator = UniqueNameGenerator.class)

image.png

执行maven打包

image.png
image.png

jd-gui查看编译后的class文件

打包之后，查看打包后的代码
image.png

项目运行

image.png
image.png