微信小程序接口实现加密

微信小程序接口实现加密教程:

场景

小程序请求的所有接口参数必须加密,后台返回数据也需要加密,并且增加Token验证

一、小程序端功能编写

1.下载一份Js版的aesUtil.js源码。【注:文章末尾会贴出所有的相关类文件】 
2.下载一份Js版的md5.js源码。 
3.在pulic.js中进行加解密操作代码如下,其中秘钥和秘钥偏移量要与后台的一致。

 

 
  1. var CryptoJS = require('aesUtil.js'); //引用AES源码js
  2. var md5 = require('md5.js')
  3.  
  4. var key = CryptoJS.enc.Utf8.parse("76CAA1C88F7F8D1D"); //十六位十六进制数作为秘钥
  5. var iv = CryptoJS.enc.Utf8.parse('91129048100F0494'); //十六位十六进制数作为秘钥偏移量
  6. //解密方法
  7. function Decrypt(word) {
  8. var encryptedHexStr = CryptoJS.enc.Hex.parse(word);
  9. var srcs = CryptoJS.enc.Base64.stringify(encryptedHexStr);
  10. var decrypt = CryptoJS.AES.decrypt(srcs, key, {
  11. iv: iv,
  12. mode: CryptoJS.mode.CBC,
  13. padding: CryptoJS.pad.Pkcs7
  14. });
  15. var decryptedStr = decrypt.toString(CryptoJS.enc.Utf8);
  16. return decryptedStr.toString();
  17. }
  18. //加密方法
  19. function Encrypt(word) {
  20. var srcs = CryptoJS.enc.Utf8.parse(word);
  21. var encrypted = CryptoJS.AES.encrypt(srcs, key, {
  22. iv: iv,
  23. mode: CryptoJS.mode.CBC,
  24. padding: CryptoJS.pad.Pkcs7
  25. });
  26. return encrypted.ciphertext.toString().toUpperCase();
  27. }
  28.  
  29. //暴露接口
  30. module.exports.Decrypt = Decrypt;
  31. module.exports.Encrypt = Encrypt;

4.在网络请求帮助类中进行参数的加密和返回数据的解密操作。

 

 
  1. var aes = require('../utils/public.js')
  2. var md5 = require("../utils/md5.js")
  3.  
  4. ...
  5.  
  6. /**
  7. * 网络请求
  8. */
  9. function request(method, loading, url, params, success, fail) {
  10. var url = BASE_URL + url;
  11. //请求参数转为JSON字符串
  12. var jsonStr = JSON.stringify(params);
  13. console.log(url + ' params=> ' + jsonStr)
  14. //根据特定规则生成Token
  15. var token = productionToken(params);
  16. //加密请求参数
  17. var aesData = aes.Encrypt(jsonStr)
  18. console.log('请求=>明文参数:' + jsonStr)
  19. console.log('请求=>加密参数:' + aesData)
  20. ...
  21. wx.request({
  22. url: url,
  23. method: method,
  24. header: {
  25. 'Content-Type': 'application/x-www-form-urlencoded;charset=utf-8',
  26. 'Token': token
  27. },
  28. data: {
  29. aesData: aesData
  30. },
  31. // data: params,
  32. success: function(res) {
  33. //判断请求结果是否成功
  34. if (res.statusCode == 200 && res.data != '' && res.data != null) {
  35. //解密返回数据
  36. console.log('返回=>加密数据:' + res.data);
  37. var result = aes.Decrypt(res.data);
  38. console.log('返回=>明文数据:'+result);
  39. success(JSON.parse(result))
  40. } else {
  41. fail()
  42. }
  43. },
  44. fail: function(res) {
  45. fail()
  46. },
  47. })
  48. }

其中生成Token的规则,【生成Token的规则可根据具体的业务逻辑自己定义,我这里使用的规则是根据请求参数的字母排序取其value并加上当前时间戳再进行MD5加密】

 

 
  1. /**
  2. * 生成Token
  3. */
  4. function productionToken(params) {
  5. var obj = util.objKeySort(params);
  6. var value = '';
  7. for (var item in obj) {
  8. value += obj[item];
  9. }
  10. //加上当前时间戳
  11. value += util.getTokenDate(new Date())
  12. //去除所有空格
  13. value = value.replace(/\s+/g, "")
  14. //进行UTF-8编码
  15. value = encodeURI(value);
  16. //进行MD5码加密
  17. value = md5.hex_md5(value)
  18. return value;
  19. }
  20. //util的排序函数
  21. function objKeySort(obj) {
  22. //先用Object内置类的keys方法获取要排序对象的属性名,再利用Array原型上的sort方法对获取的属性名进行排序,newkey是一个数组
  23. var newkey = Object.keys(obj).sort();
  24. //创建一个新的对象,用于存放排好序的键值对  
  25. var newObj = {};
  26. //遍历newkey数组
  27. for (var i = 0; i < newkey.length; i++) {
  28. //向新创建的对象中按照排好的顺序依次增加键值对
  29. newObj[newkey[i]] = obj[newkey[i]];
  30. }
  31. //返回排好序的新对象
  32. return newObj;
  33. }

 

二、服务端功能编写

由于初学SpringMVC,使用的方式不一定是最优最好的,如有不妥善之处,请各位看官多多指教  思路:

通过过滤器拦截请求参数,通过自定义参数包装器对参数进行解密。  在拦截器获取请求的Token并生成服务器端Token进行验证。  对返回参数通过JSON转换器进行加密处理。

 1.重写HttpServletRequestWrapper,在自定义的HttpServletRequestWrapper 中对参数进行处理

 

 
  1. /**
  2. * Describe:请求参数包装器 主要作用的过滤参数并解密
  3. * Created by 吴蜀黍 on 2018-08-07 09:37
  4. **/
  5. @Slf4j
  6. public class ParameterRequestWrapper extends HttpServletRequestWrapper {
  7.  
  8. private Map params = new HashMap<>();
  9.  
  10. @SuppressWarnings("unchecked")
  11. public ParameterRequestWrapper(HttpServletRequest request) {
  12. // 将request交给父类,以便于调用对应方法的时候,将其输出,其实父亲类的实现方式和第一种new的方式类似
  13. super(request);
  14. //将参数表,赋予给当前的Map以便于持有request中的参数
  15. this.params.putAll(request.getParameterMap());
  16. this.modifyParameterValues();
  17. }
  18.  
  19. //重载一个构造方法
  20. public ParameterRequestWrapper(HttpServletRequest request, Map extendParams) {
  21. this(request);
  22. addAllParameters(extendParams);//这里将扩展参数写入参数表
  23. }
  24.  
  25. private void modifyParameterValues() {//将parameter的值去除空格后重写回去
  26.  
  27. //获取加密数据
  28. String aesParameter = getParameter(Constants.NetWork.AES_DATA);
  29. log.debug("[modifyParameterValues]==========>加密数据:{}", aesParameter);
  30. //解密
  31. String decryptParameter = null;
  32. try {
  33. decryptParameter = AesUtils.decrypt(aesParameter, Constants.AES.AES_KEY);
  34. log.debug("[modifyParameterValues]==========> 解密数据:{}", decryptParameter);
  35. Map map = JSON.parseObject(decryptParameter);
  36. Set set = map.keySet();
  37. for (String key : set) {
  38. params.put(key, new String[]{String.valueOf(map.get(key))});
  39. }
  40. aesFlag(true);
  41. } catch (CommonBusinessException e) {
  42. aesFlag(false);
  43. log.error("[modifyParameterValues]", e);
  44. log.debug("[modifyParameterValues]==========>", e);
  45. }
  46. }
  47.  
  48. /**
  49. * 解密成功标志
  50. */
  51. private void aesFlag(boolean flag) {
  52. params.put(Constants.NetWork.AES_SUCCESS, new String[]{String.valueOf(flag)});
  53. }
  54.  
  55. @Override
  56. public Map getParameterMap() {
  57. // return super.getParameterMap();
  58. return params;
  59. }
  60.  
  61. @Override
  62. public Enumeration getParameterNames() {
  63. return new Vector<>(params.keySet()).elements();
  64. }
  65.  
  66. @Override
  67. public String getParameter(String name) {//重写getParameter,代表参数从当前类中的map获取
  68. String[] values = params.get(name);
  69. if (values == null || values.length == 0) {
  70. return null;
  71. }
  72. return values[0];
  73. }
  74.  
  75. public String[] getParameterValues(String name) {//同上
  76. return params.get(name);
  77. }
  78.  
  79.  
  80. public void addAllParameters(Map otherParams) {//增加多个参数
  81. for (Map.Entry entry : otherParams.entrySet()) {
  82. addParameter(entry.getKey(), entry.getValue());
  83. }
  84. }
  85.  
  86.  
  87. public void addParameter(String name, Object value) {//增加参数
  88. if (value != null) {
  89. if (value instanceof String[]) {
  90. params.put(name, (String[]) value);
  91. } else if (value instanceof String) {
  92. params.put(name, new String[]{(String) value});
  93. } else {
  94. params.put(name, new String[]{String.valueOf(value)});
  95. }
  96. }
  97. }
  98. }

新建过滤器,在拦截器中调用自定义的参数包装器

 

 
  1. /**
  2. * Describe:请求参数过滤器
  3. * Created by 吴蜀黍 on 2018-08-07 10:02
  4. **/
  5. @Slf4j
  6. public class ParameterFilter implements Filter {
  7. @Override
  8. public void init(FilterConfig filterConfig) throws ServletException {
  9. }
  10.  
  11. @Override
  12. public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
  13. //使用自定义的参数包装器对参数进行处理
  14. ParameterRequestWrapper requestWrapper = new ParameterRequestWrapper((HttpServletRequest) servletRequest);
  15. filterChain.doFilter(requestWrapper, servletResponse);
  16. }
  17.  
  18. @Override
  19. public void destroy() {
  20. }
  21. }

web.xml中对过滤器进行配置

 

 
  1. parameterFilter
  2. com.xxx.xxx.config.filter.ParameterFilter
  3. parameterFilter
  4. *.json

AES加解密操作

 

 
  1. /**
  2. * Describe:AES 加密
  3. * Created by 吴蜀黍 on 2018-08-03 17:47
  4. **/
  5. public class AesUtils {
  6. private static final String CHARSET_NAME = "UTF-8";
  7. private static final String AES_NAME = "AES";
  8. private static final String ALGORITHM = "AES/CBC/PKCS7Padding";
  9. private static final String IV = Constants.AES.AES_IV;
  10.  
  11. static {
  12. Security.addProvider(new BouncyCastleProvider());
  13. }
  14.  
  15. /**
  16. * 加密
  17. */
  18. public static String encrypt(@NotNull String content, @NotNull String key) throws CommonBusinessException {
  19. try {
  20. Cipher cipher = Cipher.getInstance(ALGORITHM);
  21. SecretKeySpec keySpec = new SecretKeySpec(key.getBytes(CHARSET_NAME), AES_NAME);
  22. AlgorithmParameterSpec paramSpec = new IvParameterSpec(IV.getBytes());
  23. cipher.init(Cipher.ENCRYPT_MODE, keySpec, paramSpec);
  24. return ParseSystemUtil.parseByte2HexStr(cipher.doFinal(content.getBytes(CHARSET_NAME)));
  25. } catch (Exception ex) {
  26. throw new CommonBusinessException("加密失败");
  27. }
  28. }
  29.  
  30. /**
  31. * 解密
  32. */
  33. public static String decrypt(@NotNull String content, @NotNull String key) throws CommonBusinessException {
  34. try {
  35. Cipher cipher = Cipher.getInstance(ALGORITHM);
  36. SecretKeySpec keySpec = new SecretKeySpec(key.getBytes(CHARSET_NAME), AES_NAME);
  37. AlgorithmParameterSpec paramSpec = new IvParameterSpec(IV.getBytes());
  38. cipher.init(Cipher.DECRYPT_MODE, keySpec, paramSpec);
  39. return new String(cipher.doFinal(Objects.requireNonNull(ParseSystemUtil.parseHexStr2Byte(content))), CHARSET_NAME);
  40. } catch (Exception ex) {
  41. throw new CommonBusinessException("解密失败");
  42. }
  43. }
  44.  
  45. }

2.新建拦截器,验证Token以及解密的判断

 

 
  1.  
  2. @Override
  3. public boolean preHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object handler) throws Exception {
  4. //如果不是映射到方法直接通过
  5. if (!(handler instanceof HandlerMethod)) {
  6. return true;
  7. }
  8. //判断参数包装器中对请求参数的解密是否成功
  9. boolean aesSuccess = Boolean.parseBoolean(httpServletRequest.getParameter(Constants.NetWork.AES_SUCCESS));
  10. if (!aesSuccess) {
  11. this.sendMsg(Constants.NetWork.CODE_DECRYPTION_FAILURE, Constants.NetWork.MEG_AES_FAIL, httpServletResponse);
  12. return false;
  13. }
  14. //获取客户端上传Token
  15. String token = httpServletRequest.getHeader(Constants.NetWork.TOKEN_HEAD_KEY);
  16. if (StringUtils.isNullOrEmpty(token)) {
  17. sendMsg(Constants.NetWork.CODE_TOKEN_INVALID, Constants.NetWork.MSG_TOKEN_EMPTY, httpServletResponse);
  18. return false;
  19. }
  20. //验证Token的有效性
  21. if (!TokenUtils.verificationToken(token, httpServletRequest.getParameterMap())) {
  22. sendMsg(Constants.NetWork.CODE_TOKEN_INVALID, Constants.NetWork.MSG_TOKEN_INVALID, httpServletResponse);
  23. return false;
  24. }
  25. return true;
  26. }
  27.  
  28. /**
  29. * 验证失败 发送消息
  30. */
  31. private void sendMsg(String msgCode, String msg, HttpServletResponse httpServletResponse) throws IOException {
  32. httpServletResponse.setContentType("application/json; charset=utf-8");
  33. PrintWriter writer = httpServletResponse.getWriter();
  34. String jsonString = JSON.toJSONString(StandardResult.create(msgCode, msg));
  35. try {
  36. //对验证失败的返回信息进行加密
  37. jsonString = AesUtils.encrypt(jsonString, Constants.AES.AES_KEY);
  38. } catch (CommonBusinessException e) {
  39. e.printStackTrace();
  40. jsonString = null;
  41. log.error("[sendMsg]", e);
  42. }
  43. writer.print(jsonString);
  44. writer.close();
  45. httpServletResponse.flushBuffer();
  46. }

在spring中对拦截器注册

 

 

Token的验证

 

 
  1.  
  2. /**
  3. * Describe:Token帮助类
  4. * Created by 吴蜀黍 on 2018-08-04 14:48
  5. **/
  6. @Slf4j
  7. public class TokenUtils {
  8. /**
  9. * 验证Token
  10. *
  11. * @param token 客户端上传Token
  12. * @param mapTypes 请求参数集合
  13. * @return boolean
  14. */
  15. public static boolean verificationToken(String token, Map mapTypes) {
  16. try {
  17. return StringUtils.saleEquals(token, getToken(mapTypes));
  18. } catch (UnsupportedEncodingException e) {
  19. log.error("[verificationToken]", e);
  20. return false;
  21. }
  22. }
  23.  
  24.  
  25. /**
  26. * 通过客户端请求参数产生Token
  27. */
  28. private static String getToken(Map mapTypes) throws UnsupportedEncodingException {
  29. List mapKes = new ArrayList<>();
  30. for (Object obj : mapTypes.keySet()) {
  31. String value = String.valueOf(obj);
  32. //去除参数中的加密相关key
  33. if (StringUtils.saleEquals(value, Constants.NetWork.AES_SUCCESS) ||
  34. StringUtils.saleEquals(value, Constants.NetWork.AES_DATA)) {
  35. break;
  36. }
  37. mapKes.add(value);
  38. }
  39. //排序key
  40. Collections.sort(mapKes);
  41. StringBuilder sb = new StringBuilder();
  42. for (String key : mapKes) {
  43. String value = ((String[]) mapTypes.get(key))[0];
  44. sb.append(value);
  45. }
  46. //加上时间戳,去除所有空格 进行MD5加密
  47. String string = sb.append(DateUtils.getDateStr(DateUtils.FORMAT_YYYYMMDDHH)).toString().replace(" ", "");
  48. return MD5.getMD5(URLEncoder.encode(string, "UTF-8"));
  49. }
  50. }

3.对返回数据进行加密处理,新建JSON转换器继承自阿里的FastJsonHttpMessageConverter

 

 
  1. /**
  2. * Describe:Json转换器 将返回数据加密
  3. * Created by 吴蜀黍 on 2018-08-07 13:57
  4. **/
  5. @Slf4j
  6. public class JsonMessageConverter extends FastJsonHttpMessageConverter {
  7.  
  8. @Override
  9. protected void writeInternal(Object object, HttpOutputMessage outputMessage) throws IOException,
  10. HttpMessageNotWritableException {
  11. OutputStream out = outputMessage.getBody();
  12. try {
  13. String jsonString = JSON.toJSONString(object);
  14. log.debug("[writeInternal]======>返回明文数据:{}" + jsonString);
  15. //对返回数据进行AES加密
  16. jsonString = AesUtils.encrypt(jsonString, Constants.AES.AES_KEY);
  17. log.debug("[writeInternal]======>返回加密数据:{}" + jsonString);
  18. out.write(jsonString.getBytes());
  19. } catch (CommonBusinessException e) {
  20. e.printStackTrace();
  21. log.error("[writeInternal]======>", e);
  22. }
  23. out.close();
  24. }
  25. }

spring中对JSON转换器进行配置

 

 
  1. text/html;charset=UTF-8
  2. application/json
  3. application/xml;charset=UTF-8
  4. WriteMapNullValue
  5. WriteNullNumberAsZero
  6. WriteNullListAsEmpty
  7. WriteNullStringAsEmpty
  8. WriteNullBooleanAsFalse
  9. WriteDateUseDateFormat

以上就是微信小程序接口加密如何实现的开发文档,更多小程序开发文档可以关注网站。

你可能感兴趣的:(微信小程序)