RSA+SHA256+BASE64对数据进行加密解密及校验

雨点打透心脏的1/2处 2021-06-30 08:41 958阅读 0赞

#需求
需要实现加密的认证机制
##认证原理
a) 密钥分配：RSA算法通过工具或方法调用生成公钥和私钥(1024bit)，请求端使用公钥，服务端使用私钥。
b) 加密方式：请求端通过密钥分配获取公钥，根据RSA加密算法将进行哈希后的明文请求进行公钥加密生成token；服务端通过密钥分配获取私钥，根据RSA解密算法将请求端的token进行私钥解密。
c) 认证方式：在服务端，如果明文请求的哈希值和私钥解密后信息的哈希值是一致的，则认为认证成功，完成授权。
d) 数据传输：RSA加密生成的是乱码，为了传输，将数据进行Base64封装，服务端收到之后进行解封装。

##认证流程
a) 请求端的认证流程，如下图所示:

这里写图片描述

b) 服务端的认证流程，如下图所示:

这里写图片描述

c) 整体流程

这里写图片描述

#编码方法的实现
Commons codec，是项目中用来处理常用的编码方法的工具类包，例如DES、SHA1、MD5、Base64，URL，Soundx等等。不仅是编码，也可用于解码。其中MD5/SHA是不可逆算法，BASE64是可逆算法。目前最新版本是1.11。RSA不在commons codec里。
##RSA的实现

  1. import javax.crypto.Cipher;
  2. import java.security.*;
  3. import java.security.interfaces.RSAPrivateKey;
  4. import java.security.interfaces.RSAPublicKey;
  5. import java.security.spec.PKCS8EncodedKeySpec;
  6. import java.security.spec.X509EncodedKeySpec;
  7. import java.util.HashMap;
  8. import java.util.Map;
  10. public class RSAUtils {
  11.     /**
  12.      * 获取公钥的key
  13.      */
  14.     private static final String PUBLIC_KEY = "RSAPublicKey";
  16.     /**
  17.      * 获取私钥的key
  18.      */
  19.     private static final String PRIVATE_KEY = "RSAPrivateKey";
  20.     /**
  21.      * 随机生成密钥对
  22.      */
  23.     public static Map<String, String> genKeyPair() {
  24.         // KeyPairGenerator类用于生成公钥和私钥对，基于RSA算法生成对象
  25.         KeyPairGenerator keyPairGen = null;
  26.         try {
  27.             keyPairGen = KeyPairGenerator.getInstance("RSA");
  28.         } catch (Exception e) {
  29.             e.printStackTrace();
  30.         }
  31.         // 初始化密钥对生成器，密钥大小为96-1024位
  32.         keyPairGen.initialize(1024,new SecureRandom());
  33.         // 生成一个密钥对，保存在keyPair中
  34.         KeyPair keyPair = keyPairGen.generateKeyPair();
  35.         // 得到私钥
  36.         RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
  37.         // 得到公钥
  38.         RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
  39.         try {
  40.             // 使用Base64对公钥加密得到字符串
  41.             String publicKeyString = Base64Utils.encode(publicKey.getEncoded());
  42.             // 使用Base64对私钥加密得到字符串
  43.             String privateKeyString = Base64Utils.encode(privateKey.getEncoded());
  44.             Map<String, String> keyMap = new HashMap<String, String>(2);
  45.             keyMap.put(PUBLIC_KEY, publicKeyString);
  46.             keyMap.put(PRIVATE_KEY, privateKeyString);
  47.             return keyMap;
  48.         } catch (Exception e) {
  49.             e.printStackTrace();
  50.             return null;
  51.         }
  52.     }
  54.     /**
  55.      * 从字符串中加载公钥
  56.      * @param publicKeyStr 公钥数据字符串
  57.      * @return RSAPublicKey 加载出来的公钥
  58.      * @exception Exception 加载公钥时产生的异常
  59.      */
  60.     public static RSAPublicKey loadPublicKeyByStr(String publicKeyStr)
  61.             throws Exception {
  62.         try {
  63.             byte[] buffer = Base64Utils.decode(publicKeyStr);
  64.             KeyFactory keyFactory = KeyFactory.getInstance("RSA");
  65.             X509EncodedKeySpec keySpec = new X509EncodedKeySpec(buffer);
  66.             return (RSAPublicKey) keyFactory.generatePublic(keySpec);
  67.         } catch (Exception e) {
  68.             throw new Exception(e);
  69.         }
  70.     }
  71.     /**
  72.      * 从字符串中加载私钥
  73.      * @param privateKeyStr 私钥数据字符串
  74.      * @return RSAPublicKey 加载出来的私钥
  75.      * @exception Exception 加载私钥时产生的异常
  76.      */
  77.     public static RSAPrivateKey loadPrivateKeyByStr(String privateKeyStr)
  78.             throws Exception {
  79.         try {
  80.             byte[] buffer = Base64Utils.decode(privateKeyStr);
  81.             PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(buffer);
  82.             KeyFactory keyFactory = KeyFactory.getInstance("RSA");
  83.             return (RSAPrivateKey) keyFactory.generatePrivate(keySpec);
  84.         } catch (Exception e) {
  85.             throw new Exception(e);
  86.         }
  87.     }
  88.     /**
  89.      * 公钥加密过程
  90.      * @param publicKey 公钥
  91.      * @param plainTextData 明文数据
  92.      * @return byte[] 加密结果
  93.      * @throws Exception 加密过程中的异常信息
  94.      */
  95.     public static byte[] encrypt(RSAPublicKey publicKey, byte[] plainTextData)
  96.             throws Exception {
  97.         if (publicKey == null) {
  98.             throw new Exception("加密公钥为空, 请设置");
  99.         }
  100.         Cipher cipher = null;
  101.         try {
  102.             // 使用默认RSA
  103.             cipher = Cipher.getInstance("RSA");
  104.             cipher.init(Cipher.ENCRYPT_MODE, publicKey);
  105.             byte[] output = cipher.doFinal(plainTextData);
  106.             return output;
  107.         } catch (Exception e) {
  108.             throw new Exception(e);
  109.         }
  110.     }
  112.     /**
  113.      * 私钥加密过程
  114.      * @param privateKey 私钥
  115.      * @param plainTextData 明文数据
  116.      * @return byte[] 加密结果
  117.      * @throws Exception 加密过程中的异常信息
  118.      */
  119.     public static byte[] encrypt(RSAPrivateKey privateKey, byte[] plainTextData)
  120.             throws Exception {
  121.         if (privateKey == null) {
  122.             throw new Exception("加密私钥为空, 请设置");
  123.         }
  124.         Cipher cipher = null;
  125.         try {
  126.             // 使用默认RSA
  127.             cipher = Cipher.getInstance("RSA");
  128.             cipher.init(Cipher.ENCRYPT_MODE, privateKey);
  129.             byte[] output = cipher.doFinal(plainTextData);
  130.             return output;
  131.         } catch (Exception e) {
  132.             throw new Exception(e);
  133.         }
  134.     }
  135.     /**
  136.      * 私钥解密过程
  137.      * @param privateKey 私钥
  138.      * @param cipherData 密文数据
  139.      * @return 明文
  140.      * @throws Exception 解密过程中的异常信息
  141.      */
  142.     public static byte[] decrypt(RSAPrivateKey privateKey, byte[] cipherData)
  143.             throws Exception {
  144.         if (privateKey == null) {
  145.             throw new Exception("解密私钥为空, 请设置");
  146.         }
  147.         Cipher cipher = null;
  148.         try {
  149.             // 使用默认RSA
  150.             cipher = Cipher.getInstance("RSA");
  151.             // cipher= Cipher.getInstance("RSA", new BouncyCastleProvider());
  152.             cipher.init(Cipher.DECRYPT_MODE, privateKey);
  153.             byte[] output = cipher.doFinal(cipherData);
  154.             return output;
  155.         } catch (Exception e) {
  156.             throw new Exception(e);
  157.         }
  158.     }
  160.     /**
  161.      * 公钥解密过程
  162.      * @param publicKey 公钥
  163.      * @param cipherData 密文数据
  164.      * @return 明文
  165.      * @throws Exception 解密过程中的异常信息
  166.      */
  167.     public static byte[] decrypt(RSAPublicKey publicKey, byte[] cipherData)
  168.             throws Exception {
  169.         if (publicKey == null) {
  170.             throw new Exception("解密公钥为空, 请设置");
  171.         }
  172.         Cipher cipher = null;
  173.         try {
  174.             // 使用默认RSA
  175.             cipher = Cipher.getInstance("RSA");
  176.             // cipher= Cipher.getInstance("RSA", new BouncyCastleProvider());
  177.             cipher.init(Cipher.DECRYPT_MODE, publicKey);
  178.             byte[] output = cipher.doFinal(cipherData);
  179.             return output;
  180.         } catch (Exception e) {
  181.             throw new Exception(e);
  182.         }
  183.     }
  185.     /**
  186.      * 获取私钥
  187.      * @param keyMap 密钥对
  188.      * @return
  189.      * @throws Exception
  190.      */
  191.     public static String getPrivateKey(Map<String, String> keyMap)
  192.             throws Exception {
  193.         String privateKey = keyMap.get(PRIVATE_KEY);
  194.         return privateKey;
  195.     }
  197.     /**
  198.      * 获取公钥
  199.      * @param keyMap 密钥对
  200.      * @return
  201.      * @throws Exception
  202.      */
  203.     public static String getPublicKey(Map<String, String> keyMap)
  204.             throws Exception {
  205.         String publicKey = keyMap.get(PUBLIC_KEY);
  206.         return publicKey;
  207.     }
  209. }

##SHA256与Base64实现
commons.codec包有这两个算法的实现，分别如下：
###SHA256

  1. import org.apache.commons.codec.digest.DigestUtils;
  2. public class SHA256Utils {
  3.     /**
  4.      * sha256加密
  5.      * */
  6.     public static String sha256Hex(String data){
  7.         return DigestUtils.sha256Hex(data);
  8.     }
  9. }

###Base64

  1. import org.apache.commons.codec.binary.Base64;
  2. public class Base64Utils
  3. {
  4.     /**
  5.      * 使用Base64加密字符串
  6.      * @return 加密之后的字符串
  7.      * @exception Exception
  8.      */
  9.     public static String encode(byte[] data){
  10.         Base64 base64 = new Base64();
  11.         String encodedData = base64.encodeAsString(data);
  12.         return encodedData;
  13.     }
  14.     /**
  15.      * 使用Base64解密
  16.      * @return 解密之后的字符串
  17.      * @exception Exception
  18.      */
  19.     public static byte[] decode(String data){
  20.         Base64 base64 = new Base64();
  21.         byte[] decodedData = base64.decodeBase64(data);
  22.         return decodedData;
  23.     }
  24. }

#Springmvc的实现
当前端对服务端进行调用时，需要在springmvc中编写一个拦截器，实现一个class继承HandlerInterceptorAdapter，并重写preHandle函数，实现如下：
在dispatcher中添加拦截器：

  1. <mvc:interceptors>
  2.     <bean class="com.zyuc.fw.web.util.tokenInterceptor"/>
  3. </mvc:interceptors>

##拦截器代码实现

  1. import com.commons.common.support.spring.security.SecurityInterceptor;
  2. import com.commons.common.utils.PropUtil;
  3. import org.slf4j.Logger;
  4. import org.slf4j.LoggerFactory;
  5. import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;
  6. import org.apache.commons.codec.binary.Base64;
  7. import javax.servlet.http.HttpServletRequest;
  8. import javax.servlet.http.HttpServletResponse;
  9. import java.security.interfaces.RSAPrivateKey;
  10. import java.util.*;
  12. public class tokenInterceptor extends HandlerInterceptorAdapter {
  13.     private static final Logger logger = LoggerFactory.getLogger(SecurityInterceptor.class);
  14.     public tokenInterceptor() {
  15.     }
  16.     private String getPrivateValues(byte[] decodeByte) throws Exception{
  17.         String privateKeyString = PropUtil.get("RSA.PrivateKey");
  18.         RSAPrivateKey privateKey = RSAUtils.loadPrivateKeyByStr(privateKeyString);
  19.         logger.info("[tokenInterceptor getPrivateValues] : privateKey = %s.", privateKey);
  20.         //私钥解密
  21.         byte[] decodedData = RSAUtils.decrypt(privateKey, decodeByte);
  22.         String token = new String(decodedData);
  23.         return token;
  24.     }
  25.     /*
  26.     * 使用拦截器在客户端访问之前对请求的数据进行校验
  27.     */
  28.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
  29.         String token = "";
  30.         String serviceToken = "";
  31.         String requestValues = "";
  32.         String requestUrl = request.getRequestURL().toString();//得到请求的URL地址
  33.         requestValues += requestUrl;
  34.         Map params = request.getParameterMap();//得到所有请求的参数
  35.         Iterator it = params.keySet().iterator();
  36.         /*获取URL+body的字符串集合*/
  37.         while(it.hasNext()){
  38.             String paramName = (String) it.next();
  39.             String paramValue = request.getParameter(paramName);
  40.             requestValues += paramName;
  41.             requestValues += paramValue;
  42.         }
  43.         /*获取token，并对token做base64解码*/
  44.         Enumeration<String> reqHeadInfos = request.getHeaderNames();//获取所有的请求头
  45.         while (reqHeadInfos.hasMoreElements()) {
  46.             token = request.getHeader("Authorization");//根据请求头的名字获取token的值
  47.             break;
  48.         }
  49.         /*如果没有添加token，默认不进行校验*/
  50.         if (null == token) {
  51.             return super.preHandle(request, response, handler);
  52.         }
  53.         byte[] decodeByte = Base64.decodeBase64(token);
  54.         /*获取私钥解密之后的token值*/
  55.         token = getPrivateValues(decodeByte);
  56.         serviceToken = SHA256Utils.sha256Hex(requestValues);
  57.         if (!serviceToken.equals(token)) {//判断两次的token值是否相同
  58.             return false;
  59.         }
  60.         return super.preHandle(request, response, handler);
  61.     }
  62. }

发表评论

表情：
评论列表 （有 0 条评论，958人围观）

还没有评论，来说两句吧...

相关阅读

    相关 base64加密解密

    1.定义 Base64是网络上最常见的用于传输8Bit字节码的编码方式之一，Base64就是一种基于64个可打印字符来表示二进制数据的方法。可查看RFC2045～RFC2

    朱雀朱雀/ 0 赞/ 506 阅读