• Gateway 接口参数加解密

    方案

    原理：

    1. 使用AES随机生成Key，加解密参数；

    2. 使用RSA加解密Key；

    具体操作：

    1. 前端使用随机Key加密参数，使用固定RSA秘钥加密Key，请求到后端；

    2. 后端收到加密Key，以及加密参数，先使用RSA解密Key，再用解密Key解密参数；

    3. 返回使用原Key加密返回参数，使用RSA加密Key；

    即：

    1. 前端请求公钥加密，后端收到私钥解密；

    2. 后端返回私钥加密，前端收到公钥解密。

    ReqFilter

    1. package cn.nocov.hospital.gateway.filter;
    2.  
    3. import cn.hutool.core.date.DatePattern;
    4. import cn.hutool.core.net.URLEncodeUtil;
    5. import cn.hutool.core.text.CharSequenceUtil;
    6. import cn.hutool.core.thread.ThreadUtil;
    7. import cn.hutool.core.util.ReUtil;
    8. import cn.hutool.core.util.StrUtil;
    9. import cn.hutool.json.JSONObject;
    10. import cn.hutool.json.JSONUtil;
    11. import cn.nocov.hospital.gateway.config.redis.RedisUtil;
    12. import cn.nocov.hospital.gateway.util.IpUtil;
    13. import cn.nocov.hospital.gateway.util.NacosCfgUtil;
    14. import cn.nocov.hospital.gateway.util.RequestUriUtil;
    15. import cn.nocov.hospital.gateway.util.RsaAesUtil;
    16. import cn.nocov.hospital.gateway.util.TokenUtil;
    17. import cn.nocov.hospital.gateway.util.TokenUtil.ProductPlatformEnum;
    18. import com.alibaba.fastjson.JSON;
    19. import com.google.common.collect.Maps;
    20. import java.net.URI;
    21. import java.nio.charset.StandardCharsets;
    22. import java.time.Duration;
    23. import java.time.LocalDateTime;
    24. import java.util.Map;
    25. import java.util.concurrent.TimeUnit;
    26. import javax.annotation.Resource;
    27. import lombok.extern.slf4j.Slf4j;
    28. import org.slf4j.MDC;
    29. import org.springframework.cloud.gateway.filter.GatewayFilterChain;
    30. import org.springframework.cloud.gateway.filter.GlobalFilter;
    31. import org.springframework.cloud.gateway.filter.factory.rewrite.CachedBodyOutputMessage;
    32. import org.springframework.cloud.gateway.support.BodyInserterContext;
    33. import org.springframework.context.annotation.Configuration;
    34. import org.springframework.core.Ordered;
    35. import org.springframework.core.io.buffer.DataBuffer;
    36. import org.springframework.http.HttpHeaders;
    37. import org.springframework.http.HttpMethod;
    38. import org.springframework.http.MediaType;
    39. import org.springframework.http.ResponseCookie;
    40. import org.springframework.http.server.reactive.ServerHttpRequest;
    41. import org.springframework.http.server.reactive.ServerHttpRequest.Builder;
    42. import org.springframework.http.server.reactive.ServerHttpRequestDecorator;
    43. import org.springframework.http.server.reactive.ServerHttpResponse;
    44. import org.springframework.web.bind.annotation.RequestMethod;
    45. import org.springframework.web.reactive.function.BodyInserter;
    46. import org.springframework.web.reactive.function.BodyInserters;
    47. import org.springframework.web.reactive.function.server.HandlerStrategies;
    48. import org.springframework.web.reactive.function.server.ServerRequest;
    49. import org.springframework.web.server.ServerWebExchange;
    50. import org.springframework.web.util.UriComponentsBuilder;
    51. import reactor.core.publisher.Flux;
    52. import reactor.core.publisher.Mono;
    53.  
    54. /**
    55.  * @author: Zek
    56.  * @date: 2020/8/13 on 4:36 下午
    57.  * @description: 请求过滤器，注意：@Order、Ordered虽然都是执行顺序，但是使用@Order注解会导致url少一位，不知道啥问题
    58.  */
    59. @Slf4j
    60. @Configuration
    61. public class ReqFilter implements GlobalFilter, Ordered {
    62.  
    63.   @Resource private NacosCfgUtil nacosCfgUtil;
    64.   @Resource private RedisUtil redisUtil;
    65.   @Resource private RequestUriUtil requestUriUtil;
    66.  
    67.   @Override
    68.   public Mono filter(ServerWebExchange exchange, GatewayFilterChain chain) {
    69.     MDC.clear();
    70.     ServerHttpRequest request = exchange.getRequest();
    71.     ServerHttpResponse response = exchange.getResponse();
    72.     if (RequestMethod.OPTIONS.name().equals(request.getMethodValue())) {
    73.       return chain.filter(exchange);
    74.     }
    75.     URI requestUri = request.getURI();
    76.     String uri = requestUri.getPath();
    77.     String url = requestUri.toString();
    78.     HttpHeaders headers = request.getHeaders();
    79.     ProductPlatformEnum appPlatform =
    80.         ProductPlatformEnum.toEnum(headers.getFirst(Constant.HEADER_PLATFORM));
    81.     MDC.put(Constant.HEADER_PLATFORM, appPlatform == null ? "" : appPlatform.name());
    82.     String appVersion = headers.getFirst(Constant.HEADER_VERSION);
    83.     MDC.put(Constant.HEADER_VERSION, appVersion);
    84.     String requestId = headers.getFirst(Constant.HEADER_REQUEST_ID);
    85.     MDC.put(Constant.HEADER_REQUEST_ID, requestId);
    86.     HttpMethod method = request.getMethod();
    87.     log.info(
    88.         "{}--------------------》Send {} To {}\n{}",
    89.         requestId,
    90.         method,
    91.         url,
    92.         headers.toSingleValueMap());
    93.     boolean needEncrypt = requestUriUtil.noTokenNeedEncrypt(uri);
    94.     if (needEncrypt) {
    95.       // 判断请求方式是否需要加密
    96.       needEncrypt = needEncryptJudgeRequest(headers, method);
    97.       if (needEncrypt && !TokenUtil.checkHeader(appPlatform, appVersion, requestId)) {
    98.         return errorReturn(response, requestId, "512", "版本过低，请前往商店更新最新版本");
    99.       }
    100.     } else {
    101.       if (CharSequenceUtil.isNotBlank(requestId)) {
    102.         requestId = TokenUtil.getRequestId();
    103.       }
    104.     }
    105.     if (CharSequenceUtil.isNotBlank(requestId)) {
    106.       response.getHeaders().set(Constant.HEADER_REQUEST_ID, requestId);
    107.     }
    108.     String ip = IpUtil.getIp(request);
    109.     Builder mutate =
    110.         request
    111.             .mutate()
    112.             .header(Constant.HEADER_IP, ip)
    113.             .header(Constant.HEADER_REQUEST_ID, requestId);
    114.     // 需要校验token的接口
    115.     String token = "";
    116.     if (requestUriUtil.needToken(uri)) {
    117.       if (appPlatform == null) {
    118.         log.info("{}--------------------》登录校验失败：appPlatform == null，url:{}", requestId, url);
    119.         return errorReturn(response, requestId, "302", "登录验证失败，请重新登录");
    120.       }
    121.       token = TokenUtil.getToken(request, appPlatform);
    122.       if (CharSequenceUtil.isBlank(token)) {
    123.         log.info("{}--------------------》登录校验失败：cookie token == null/''，url:{}", requestId, url);
    124.         return errorReturn(response, requestId, "302", "登录验证失败，请重新登录");
    125.       }
    126.       String userInfoKey = redisUtil.get(loginRedisKey);
    127.       String redisPlatform = getPlatform(userInfoKey);
    128.       xxxxx;
    129.       String userId = getUserId(userInfoKey);
    130.       MDC.put(Constant.HEADER_USER_ID, userId);
    131.       mutate
    132.           .header(Constant.HEADER_USER_ID, userId)
    133.           .header(Constant.HEADER_VERSION, appVersion)
    134.           .header(Constant.HEADER_PLATFORM, appPlatform.name())
    135.           .header(
    136.               Constant.HEADER_USERNAME,
    137.               URLEncodeUtil.encode(redisUtil.hGet(userInfoKey, "username")));
    138.     }
    139.     if (hasRepeatRequest(token, ip, appPlatform, method + uri)) {
    140.       log.info("{}--------------------》重复请求{}", requestId, method + uri);
    141.       return errorReturn(response, requestId, "512", "请稍等一下喔（勿频繁点击）");
    142.     }
    143.     // post请求时，如果是文件上传之类的请求，不修改请求消息体
    144.     exchange.getAttributes().put(Constant.EXCHANGE_HAS_AES, needEncrypt);
    145.     if (needEncrypt) {
    146.       exchange.getAttributes().put(Constant.EXCHANGE_REQUEST_ID, requestId);
    147.       Map copyOfContextMap = MDC.getCopyOfContextMap();
    148.       try {
    149.         if (HttpMethod.GET == method) {
    150.           return encryptParamsGet(
    151.               chain,
    152.               exchange,
    153.               request,
    154.               response,
    155.               mutate,
    156.               requestUri,
    157.               requestId,
    158.               appPlatform,
    159.               copyOfContextMap);
    160.         } else {
    161.           return encryptParamsPost(
    162.               chain, exchange, headers, requestId, appPlatform, copyOfContextMap);
    163.         }
    164.       } catch (Exception e) {
    165.         log.error("{}--------------------》加解密失败：", requestId, e);
    166.         return errorReturn(response, requestId, "512", "请求异常");
    167.       }
    168.     }
    169.     return chain.filter(exchange.mutate().request(request).build());
    170.   }
    171.  
    172.   private Mono encryptParamsGet(
    173.       GatewayFilterChain chain,
    174.       ServerWebExchange exchange,
    175.       ServerHttpRequest request,
    176.       ServerHttpResponse response,
    177.       Builder mutate,
    178.       URI requestUri,
    179.       String requestIdValue,
    180.       ProductPlatformEnum appPlatform,
    181.       Map copyOfContextMap) {
    182.     MDC.setContextMap(copyOfContextMap);
    183.     Map queryParams = request.getQueryParams().toSingleValueMap();
    184.     if (!queryParams.isEmpty() && queryParams.containsKey("v")) {
    185.       String v = queryParams.get("v");
    186.       if (CharSequenceUtil.isBlank(v)) {
    187.         return errorReturn(response, requestIdValue, "512", "请求异常");
    188.       }
    189.       log.info("{}--------------------》原V:{}", requestIdValue, v);
    190.       v = RsaAesUtil.rsaDecryptAesKey(appPlatform, v);
    191.       exchange.getAttributes().put(Constant.EXCHANGE_AES_KEY, v);
    192.       URI uri;
    193.       if (queryParams.containsKey("d")) {
    194.         // 替换查询参数
    195.         String d = queryParams.get("d");
    196.         log.info("{}--------------------》原D:{}", requestIdValue, d);
    197.         String decryptParams =
    198.             CharSequenceUtil.isBlank(d)
    199.                 ? ""
    200.                 : RsaAesUtil.aesDecryptParams(v.getBytes(StandardCharsets.UTF_8), d);
    201.         log.info("{}--------------------》解D:{}", requestIdValue, decryptParams);
    202.         uri =
    203.             UriComponentsBuilder.fromUri(requestUri)
    204.                 .replaceQuery(URLEncodeUtil.encode(decryptParams))
    205.                 .build(true)
    206.                 .toUri();
    207.       } else {
    208.         uri = UriComponentsBuilder.fromUri(requestUri).replaceQuery("").build(true).toUri();
    209.       }
    210.       ServerHttpRequest build = mutate.uri(uri).build();
    211.       log.info(
    212.           "{}--------------------》重构 {} To {}\n{}",
    213.           requestIdValue,
    214.           build.getMethodValue(),
    215.           build.getURI(),
    216.           build.getHeaders().toSingleValueMap());
    217.       return chain.filter(exchange.mutate().request(build).build());
    218.     } else {
    219.       return errorReturn(response, requestIdValue, "512", "请求异常");
    220.     }
    221.   }
    222.  
    223.   private Mono encryptParamsPost(
    224.       GatewayFilterChain chain,
    225.       ServerWebExchange exchange,
    226.       HttpHeaders httpHeaders,
    227.       String requestIdValue,
    228.       ProductPlatformEnum appPlatform,
    229.       Map copyOfContextMap) {
    230.     // read & modify body
    231.     MDC.setContextMap(copyOfContextMap);
    232.     ServerRequest serverRequest =
    233.         ServerRequest.create(exchange, HandlerStrategies.withDefaults().messageReaders());
    234.     Mono modifiedBody =
    235.         serverRequest
    236.             .bodyToMono(String.class)
    237.             .flatMap(
    238.                 body -> {
    239.                   MDC.setContextMap(copyOfContextMap);
    240.                   // 对原先的body进行修改操作
    241.                   String str = StrUtil.str(body, StandardCharsets.UTF_8);
    242.                   log.info("{}--------------------》收参:{}", requestIdValue, str);
    243.                   JSONObject jsonObject = JSONUtil.parseObj(str);
    244.                   if (JSONUtil.isNull(jsonObject)) {
    245.                     return Mono.error(new RuntimeException("请求异常"));
    246.                   }
    247.                   if (!jsonObject.containsKey("v")) {
    248.                     return Mono.error(new RuntimeException("请求异常"));
    249.                   }
    250.                   String v = jsonObject.getStr("v");
    251.                   if (CharSequenceUtil.isBlank(v)) {
    252.                     return Mono.error(new RuntimeException("请求异常"));
    253.                   }
    254.                   v = RsaAesUtil.rsaDecryptAesKey(appPlatform, v);
    255.                   exchange.getAttributes().put(Constant.EXCHANGE_AES_KEY, v);
    256.                   if (jsonObject.containsKey("d")) {
    257.                     String d = jsonObject.getStr("d");
    258.                     d =
    259.                         CharSequenceUtil.isBlank(d)
    260.                             ? JSONUtil.toJsonStr(JSONUtil.createObj())
    261.                             : RsaAesUtil.aesDecryptParams(v.getBytes(StandardCharsets.UTF_8), d);
    262.                     log.info("{}--------------------》解D:{}", requestIdValue, d);
    263.                     return Mono.just(d);
    264.                   } else {
    265.                     return Mono.empty();
    266.                   }
    267.                 });
    268.     BodyInserter bodyInserter = BodyInserters.fromPublisher(modifiedBody, String.class);
    269.     HttpHeaders headers = new HttpHeaders();
    270.     headers.putAll(httpHeaders);
    271.     headers.remove(HttpHeaders.CONTENT_LENGTH);
    272.     CachedBodyOutputMessage outputMessage = new CachedBodyOutputMessage(exchange, headers);
    273.     return bodyInserter
    274.         .insert(outputMessage, new BodyInserterContext())
    275.         .then(
    276.             Mono.defer(
    277.                 () -> {
    278.                   MDC.setContextMap(copyOfContextMap);
    279.                   ServerHttpRequestDecorator decorator =
    280.                       new ServerHttpRequestDecorator(exchange.getRequest()) {
    281.                         @Override
    282.                         public HttpHeaders getHeaders() {
    283.                           long contentLength = headers.getContentLength();
    284.                           HttpHeaders httpHeaders = new HttpHeaders();
    285.                           httpHeaders.putAll(super.getHeaders());
    286.                           if (contentLength > 0L) {
    287.                             httpHeaders.setContentLength(contentLength);
    288.                           } else {
    289.                             httpHeaders.set(HttpHeaders.TRANSFER_ENCODING, "chunked");
    290.                           }
    291.                           return httpHeaders;
    292.                         }
    293.  
    294.                         @Override
    295.                         public Flux getBody() {
    296.                           return outputMessage.getBody();
    297.                         }
    298.                       };
    299.                   log.info(
    300.                       "{}--------------------》重构 {} To {}\n{}",
    301.                       requestIdValue,
    302.                       decorator.getMethodValue(),
    303.                       decorator.getURI(),
    304.                       decorator.getHeaders().toSingleValueMap());
    305.                   return chain.filter(exchange.mutate().request(decorator).build());
    306.                 }));
    307.   }
    308.  
    309.   private Mono errorReturn(
    310.       ServerHttpResponse response, String requestId, String code, String msg) {
    311.     if ("302".equals(code)) {
    312.       response.addCookie(
    313.           ResponseCookie.from(Constant.TOKEN, "").path("/").maxAge(Duration.ofSeconds(0L)).build());
    314.     }
    315.     response.getHeaders().set(HttpHeaders.CONTENT_TYPE, "application/json;charset=UTF-8");
    316.     Map map = Maps.newHashMapWithExpectedSize(3);
    317.     map.put("code", code);
    318.     map.put("msg", msg);
    319.     map.put("obj", null);
    320.     log.info("{}--------------------》异常返回：{}", requestId, map);
    321.     MDC.clear();
    322.     return response.writeWith(
    323.         Flux.just(response.bufferFactory().wrap(JSON.toJSONString(map).getBytes())));
    324.   }
    325.  
    326.   /**
    327.    * 是否加解密
    328.    *
    329.    * @param headers
    330.    * @return
    331.    */
    332.   private boolean needEncryptJudgeRequest(HttpHeaders headers, HttpMethod method) {
    333.     return method == HttpMethod.GET
    334.         || (method == HttpMethod.POST
    335.             && (CharSequenceUtil.containsAny(
    336.                 headers.getFirst(HttpHeaders.CONTENT_TYPE), MediaType.APPLICATION_JSON_VALUE)));
    337.   }
    338.  
    339.   /**
    340.    * 检查重复请求
    341.    *
    342.    * @param token 判断唯一请求
    343.    * @param ip 判断唯一请求
    344.    * @param appPlatform 判断唯一请求
    345.    * @param uri
    346.    * @return
    347.    */
    348.   public boolean hasRepeatRequest(
    349.       String token, String ip, ProductPlatformEnum appPlatform, String uri) {
    350.     return xxx;
    351.   }
    352.  
    353.   private String getPlatform(String userInfoKey) {
    354.     return xxx;
    355.   }
    356.  
    357.   private String getUserId(String loginRedisValue) {
    358.     return xxx;
    359.   }
    360.  
    361.   private void asyncUserAgentFun(HttpHeaders headers) {
    362.     log.info(xxx);
    363.   }
    364.  
    365.   /** 顺序:数字越小，越先执行 */
    366.   @Override
    367.   public int getOrder() {
    368.     return -2;
    369.   }
    370. }

    RespFilter

    1. package cn.nocov.hospital.gateway.filter;
    2.  
    3. import cn.hutool.core.text.CharSequenceUtil;
    4. import cn.hutool.core.util.StrUtil;
    5. import cn.hutool.json.JSONObject;
    6. import cn.hutool.json.JSONUtil;
    7. import cn.nocov.hospital.gateway.util.RsaAesUtil;
    8. import java.nio.charset.StandardCharsets;
    9. import java.util.Map;
    10. import lombok.extern.slf4j.Slf4j;
    11. import org.reactivestreams.Publisher;
    12. import org.slf4j.MDC;
    13. import org.springframework.cloud.gateway.filter.GatewayFilterChain;
    14. import org.springframework.cloud.gateway.filter.GlobalFilter;
    15. import org.springframework.context.annotation.Configuration;
    16. import org.springframework.core.Ordered;
    17. import org.springframework.core.io.buffer.DataBuffer;
    18. import org.springframework.core.io.buffer.DataBufferFactory;
    19. import org.springframework.core.io.buffer.DataBufferUtils;
    20. import org.springframework.core.io.buffer.DefaultDataBufferFactory;
    21. import org.springframework.http.server.reactive.ServerHttpResponse;
    22. import org.springframework.http.server.reactive.ServerHttpResponseDecorator;
    23. import org.springframework.web.server.ServerWebExchange;
    24. import reactor.core.publisher.Flux;
    25. import reactor.core.publisher.Mono;
    26.  
    27. /**
    28.  * @author: Zek
    29.  * @date: 2020/8/13 on 4:36 下午
    30.  * @description:
    31.  */
    32. @Slf4j
    33. @Configuration
    34. public class RespFilter implements GlobalFilter, Ordered {
    35.  
    36.   @Override
    37.   public Mono filter(ServerWebExchange exchange, GatewayFilterChain chain) {
    38.     Object objHasAes = exchange.getAttributes().get(Constant.EXCHANGE_HAS_AES);
    39.     Boolean hasAes = objHasAes == null ? null : (Boolean) objHasAes;
    40.     String requestIdValue = (String) exchange.getAttributes().get(Constant.EXCHANGE_REQUEST_ID);
    41.     ServerHttpResponse originalResponse = exchange.getResponse();
    42.     originalResponse
    43.         .getHeaders()
    44.         .set(
    45.             Constant.HEADER_REQUEST_ID,
    46.             CharSequenceUtil.isBlank(requestIdValue) ? "" : requestIdValue);
    47.     if (hasAes == null || !hasAes) {
    48.       clearExchange(exchange);
    49.       return chain.filter(exchange.mutate().response(originalResponse).build());
    50.     }
    51.     String key = (String) exchange.getAttributes().get(Constant.EXCHANGE_AES_KEY);
    52.     log.info("{}--------------------》Exchange：{}", requestIdValue, key);
    53.     Map copyOfContextMap = MDC.getCopyOfContextMap();
    54.     DataBufferFactory bufferFactory = originalResponse.bufferFactory();
    55.     ServerHttpResponseDecorator decoratedResponse =
    56.         new ServerHttpResponseDecorator(originalResponse) {
    57.           @Override
    58.           public Mono writeWith(Publisher body) {
    59.             if (body instanceof Flux) {
    60.               Fluxextends DataBuffer> fluxBody = (Fluxextends DataBuffer>) body;
    61.               return super.writeWith(
    62.                   fluxBody
    63.                       .buffer()
    64.                       .map(
    65.                           dataBuffer -> {
    66.                             MDC.setContextMap(copyOfContextMap);
    67.                             DataBufferFactory dataBufferFactory = new DefaultDataBufferFactory();
    68.                             DataBuffer join = dataBufferFactory.join(dataBuffer);
    69.                             byte[] content = new byte[join.readableByteCount()];
    70.                             join.read(content);
    71.                             // 释放掉内存
    72.                             DataBufferUtils.release(join);
    73.                             String respBody = StrUtil.str(content, StandardCharsets.UTF_8);
    74.                             if (!JSONUtil.isTypeJSON(respBody)) {
    75.                               log.error(
    76.                                   "{}--------------------》非JSON:{}", requestIdValue, respBody);
    77.                               return bufferFactory.wrap(content);
    78.                             }
    79.                             JSONObject resp = JSONUtil.parseObj(respBody);
    80.                             String obj = resp.getStr("obj");
    81.                             if (!JSONUtil.isNull(obj)) {
    82.                               resp.set(
    83.                                   "obj",
    84.                                   RsaAesUtil.aesEncryptParams(
    85.                                       key.getBytes(StandardCharsets.UTF_8), obj));
    86.                             }
    87.                             log.info(
    88.                                 "{}--------------------》返D:{}",
    89.                                 requestIdValue,
    90.                                 (respBody.length() > 1000
    91.                                     ? respBody.substring(0, 1000) + "......."
    92.                                     : respBody));
    93.                             // 加密后的数据返回给客户端
    94.                             return bufferFactory.wrap(JSONUtil.toJsonStr(resp).getBytes());
    95.                           }));
    96.             }
    97.             return super.writeWith(body);
    98.           }
    99.         };
    100.     clearExchange(exchange);
    101.     MDC.clear();
    102.     return chain.filter(exchange.mutate().response(decoratedResponse).build());
    103.   }
    104.   /** 顺序:数字越小，越先执行 */
    105.   @Override
    106.   public int getOrder() {
    107.     return -1;
    108.   }
    109.  
    110.   private void clearExchange(ServerWebExchange exchange) {
    111.     exchange.getAttributes().remove(Constant.EXCHANGE_AES_KEY);
    112.     exchange.getAttributes().remove(Constant.EXCHANGE_HAS_AES);
    113.   }
    114. }

    RsaAesUtil

    1. package cn.nocov.hospital.gateway.util;
    2.  
    3. import cn.hutool.core.lang.Console;
    4. import cn.hutool.crypto.SecureUtil;
    5. import cn.hutool.crypto.asymmetric.KeyType;
    6. import cn.hutool.crypto.asymmetric.RSA;
    7. import cn.hutool.crypto.symmetric.AES;
    8. import cn.nocov.hospital.gateway.util.TokenUtil.ProductPlatformEnum;
    9. import javax.crypto.spec.IvParameterSpec;
    10.  
    11. /**
    12.  * @author: Zek
    13.  * @date: 2022/3/8 on 11:05 AM
    14.  * @desc:
    15.  */
    16. public class RsaAesUtil {
    17.  
    18.   @Deprecated
    19.   private static final RSA XXXX =
    20.       SecureUtil.rsa(
    21.           "xx",
    22.           "xx");
    23.  
    24.   /**
    25.    * AES 解密
    26.    *
    27.    * @param aesKey
    28.    * @param aesParams
    29.    * @return
    30.    */
    31.   public static String aesDecryptParams(byte[] aesKey, String aesParams) {
    32.     AES aes = new AES("CBC", "PKCS7Padding", aesKey, new IvParameterSpec(aesKey, 0, 16).getIV());
    33.     return aes.decryptStr(aesParams);
    34.   }
    35.  
    36.   /**
    37.    * AES 加密
    38.    *
    39.    * @param aesKey
    40.    * @param aesParams
    41.    * @return
    42.    */
    43.   public static String aesEncryptParams(byte[] aesKey, String aesParams) {
    44.     return aes(aesKey).encryptBase64(aesParams);
    45.   }
    46.  
    47.   /**
    48.    * 获取aes
    49.    *
    50.    * @param aesKey
    51.    * @return
    52.    */
    53.   private static AES aes(byte[] aesKey) {
    54.     return new AES("CBC", "PKCS7Padding", aesKey, new IvParameterSpec(aesKey, 0, 16).getIV());
    55.   }
    56.  
    57.   /**
    58.    * rsa 解密 aesKey
    59.    *
    60.    * @param appPlatform
    61.    * @param aesKey
    62.    * @return
    63.    */
    64.   public static String rsaDecryptAesKey(ProductPlatformEnum appPlatform, String aesKey) {
    65.     return getRsa(appPlatform).decryptStr(aesKey, KeyType.PrivateKey);
    66.   }
    67.  
    68.   /**
    69.    * 获取RSA
    70.    *
    71.    * @param appPlatform
    72.    * @return
    73.    */
    74.   private static RSA getRsa(ProductPlatformEnum appPlatform) {
    75.     xxxxxxx
    76.     }
    77.   }
    78.  
    79.   public static void main(String[] args) {
    80.     RSA rsa = SecureUtil.rsa();
    81.     Console.log(rsa.getPrivateKeyBase64());
    82.     Console.log(rsa.getPublicKeyBase64());
    83.   }
    84. }

    效果

     

     问题：

    会随机产生HTTP method names must be tokens，下篇文章解决（已解决但是不知道原因）；

    解决：

    Gateway加解密接口HTTP method names must be tokens_邪神大叔的博客-CSDN博客https://blog.csdn.net/qq_17213067/article/details/127859571

  • 相关阅读:
    原来栈和队列之间其实也是可以互相转换的啊
    猴子也能学会的jQuery第一期——什么是jQuery
    计算机视觉中的自监督学习
    面试五 -bind 和 function
    关于Comparable、Comparator接口返回值决定顺序的问题
    二、工业方案推荐系统
    每日一题 1143最长公共子序列（LCS）（灵神版本）
    初阶数据结构学习记录——아홉 二叉树和堆（2）
    “Vue进阶：深入理解插值、指令、过滤器、计算属性和监听器“
    web：[极客大挑战 2019]PHP
  • 原文地址：https://blog.csdn.net/qq_17213067/article/details/127859326