devbox
你好赵伟
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

最详细的SpringBoot实现接口校验签名调用_springboot接口加签验签

作者：你好赵伟 | 2024-02-28 02:33:00

赞

踩

springboot接口加签验签

代码地址：GitHub - passerbyYSQ/DemoRepository: 各种开发小demo

目录

概念

开放接口

验签

接口验签调用流程

1. 约定签名算法

2. 颁发非对称密钥对

3. 生成请求参数签名

4. 请求携带签名调用

代码设计

1. 签名配置类

2. 签名管理类

3. 自定义验签注解

4. AOP实现验签逻辑

5. 解决请求体只能读取一次

6. 自定义工具类

概念

开放接口

        开放接口是指不需要登录凭证就允许被第三方系统调用的接口。为了防止开放接口被恶意调用，开放接口一般都需要验签才能被调用。提供开放接口的系统下面统一简称为"原系统"。

验签

      验签是指第三方系统在调用接口之前，需要按照原系统的规则根据所有请求参数生成一个签名（字符串），在调用接口时携带该签名。原系统会验证签名的有效性，只有签名验证有效才能正常调用接口，否则请求会被驳回。

接口验签调用流程

1. 约定签名算法

        第三方系统作为调用方，需要与原系统协商约定签名算法（下面以SHA256withRSA签名算法为例）。同时约定一个名称（callerID），以便在原系统中来唯一标识调用方系统。

2. 颁发非对称密钥对

        签名算法约定后之后，原系统会为每一个调用方系统专门生成一个专属的非对称密钥对（RSA密钥对）。私钥颁发给调用方系统，公钥由原系统持有。注意，调用方系统需要保管好私钥（存到调用方系统的后端）。因为对于原系统而言，调用方系统是消息的发送方，其持有的私钥唯一标识了它的身份是原系统受信任的调用方。调用方系统的私钥一旦泄露，调用方对原系统毫无信任可言。

3. 生成请求参数签名

        签名算法约定后之后，生成签名的原理如下（活动图）。为了确保生成签名的处理细节与原系统的验签逻辑是匹配的，原系统一般都提供jar包或者代码片段给调用方来生成签名，否则可能会因为一些处理细节不一致导致生成的签名是无效的。

4. 请求携带签名调用

路径参数中放入约定好的callerID，请求头中放入调用方自己生成的签名

代码设计

1. 签名配置类

相关的自定义yml配置如下。RSA的公钥和私钥可以使用hutool的SecureUtil工具类来生成，注意公钥和私钥是base64编码后的字符串

定义一个配置类来存储上述相关的自定义yml配置

  1. import cn.hutool.crypto.asymmetric.SignAlgorithm;
  2. import lombok.Data;
  3. import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
  4. import org.springframework.boot.context.properties.ConfigurationProperties;
  5. import org.springframework.stereotype.Component;
  6.  
  7. import java.util.Map;
  8.  
  9. /**
  10.  * 签名的相关配置
  11.  */
  12. @Data
  13. @ConditionalOnProperty(value = "secure.signature.enable", havingValue = "true")  // 根据条件注入bean
  14. @Component
  15. @ConfigurationProperties("secure.signature")
  16. public class SignatureProps {
  17.     private Boolean enable;
  18.     private Map<String, KeyPairProps> keyPair;
  19.  
  20.     @Data
  21.     public static class KeyPairProps {
  22.         private SignAlgorithm algorithm;
  23.         private String publicKeyPath;
  24.         private String publicKey;
  25.         private String privateKeyPath;
  26.         private String privateKey;
  27.     }
  28. }

2. 签名管理类

定义一个管理类，持有上述配置，并暴露生成签名和校验签名的方法。

注意，生成的签名是将字节数组进行十六进制编码后的字符串，验签时需要将签名字符串进行十六进制解码成字节数组

  1. import cn.hutool.core.io.IoUtil;
  2. import cn.hutool.core.io.resource.ResourceUtil;
  3. import cn.hutool.core.util.HexUtil;
  4. import cn.hutool.crypto.SecureUtil;
  5. import cn.hutool.crypto.asymmetric.Sign;
  6. import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
  7. import org.springframework.stereotype.Component;
  8. import org.springframework.util.ObjectUtils;
  9. import top.ysqorz.signature.model.SignatureProps;
  10.  
  11. import java.nio.charset.StandardCharsets;
  12.  
  13. @ConditionalOnBean(SignatureProps.class)
  14. @Component
  15. public class SignatureManager {
  16.     private final SignatureProps signatureProps;
  17.  
  18.     public SignatureManager(SignatureProps signatureProps) {
  19.         this.signatureProps = signatureProps;
  20.         loadKeyPairByPath();
  21.     }
  22.  
  23.     /**
  24.      * 验签。验证不通过可能抛出运行时异常CryptoException
  25.      *
  26.      * @param callerID  调用方的唯一标识
  27.      * @param rawData   原数据
  28.      * @param signature 待验证的签名(十六进制字符串)
  29.      * @return 验证是否通过
  30.      */
  31.     public boolean verifySignature(String callerID, String rawData, String signature) {
  32.         Sign sign = getSignByCallerID(callerID);
  33.         if (ObjectUtils.isEmpty(sign)) {
  34.             return false;
  35.         }
  36.  
  37.         // 使用公钥验签
  38.         return sign.verify(rawData.getBytes(StandardCharsets.UTF_8), HexUtil.decodeHex(signature));
  39.     }
  40.  
  41.     /**
  42.      * 生成签名
  43.      *
  44.      * @param callerID 调用方的唯一标识
  45.      * @param rawData  原数据
  46.      * @return 签名(十六进制字符串)
  47.      */
  48.     public String sign(String callerID, String rawData) {
  49.         Sign sign = getSignByCallerID(callerID);
  50.         if (ObjectUtils.isEmpty(sign)) {
  51.             return null;
  52.         }
  53.         return sign.signHex(rawData);
  54.     }
  55.  
  56.     public SignatureProps getSignatureProps() {
  57.         return signatureProps;
  58.     }
  59.  
  60.     public SignatureProps.KeyPairProps getKeyPairPropsByCallerID(String callerID) {
  61.         return signatureProps.getKeyPair().get(callerID);
  62.     }
  63.  
  64.     private Sign getSignByCallerID(String callerID) {
  65.         SignatureProps.KeyPairProps keyPairProps = signatureProps.getKeyPair().get(callerID);
  66.         if (ObjectUtils.isEmpty(keyPairProps)) {
  67.             return null; // 无效的、不受信任的调用方
  68.         }
  69.         return SecureUtil.sign(keyPairProps.getAlgorithm(), keyPairProps.getPrivateKey(), keyPairProps.getPublicKey());
  70.     }
  71.  
  72.     /**
  73.      * 加载非对称密钥对
  74.      */
  75.     private void loadKeyPairByPath() {
  76.         // 支持类路径配置，形如：classpath:secure/public.txt
  77.         // 公钥和私钥都是base64编码后的字符串
  78.         signatureProps.getKeyPair()
  79.                 .forEach((key, keyPairProps) -> {
  80.                     // 如果配置了XxxKeyPath，则优先XxxKeyPath
  81.                     keyPairProps.setPublicKey(loadKeyByPath(keyPairProps.getPublicKeyPath()));
  82.                     keyPairProps.setPrivateKey(loadKeyByPath(keyPairProps.getPrivateKeyPath()));
  83.                     if (ObjectUtils.isEmpty(keyPairProps.getPublicKey()) ||
  84.                             ObjectUtils.isEmpty(keyPairProps.getPrivateKey())) {
  85.                         throw new RuntimeException("No public and private key files configured");
  86.                     }
  87.                 });
  88.     }
  89.  
  90.     private String loadKeyByPath(String path) {
  91.         if (ObjectUtils.isEmpty(path)) {
  92.             return null;
  93.         }
  94.         return IoUtil.readUtf8(ResourceUtil.getStream(path));
  95.     }
  96. }

3. 自定义验签注解

有些接口需要验签，但有些接口并不需要，为了灵活控制哪些接口需要验签，自定义一个验签注解

  1. import java.lang.annotation.*;
  2.  
  3. /**
  4.  * 该注解标注于Controller类的方法上，表明该请求的参数需要校验签名
  5.  */
  6. @Documented
  7. @Retention(RetentionPolicy.RUNTIME)
  8. @Target({ElementType.METHOD, ElementType.TYPE})
  9. public @interface VerifySignature {
  10. }

4. AOP实现验签逻辑

        验签逻辑不能放在拦截器中，因为拦截器中不能直接读取body的输入流，否则会造成后续@RequestBody的参数解析器读取不到body。
        由于body输入流只能读取一次，因此需要使用ContentCachingRequestWrapper包装请求，缓存body内容（见第5点），但是该类的缓存时机是在@RequestBody的参数解析器中。
        因此，满足2个条件才能获取到ContentCachingRequestWrapper中的body缓存：

  • 接口的入参必须存在@RequestBody
  • 读取body缓存的时机必须在@RequestBody的参数解析之后，比如说：AOP、Controller层的逻辑内。注意拦截器的时机是在参数解析之前的

        综上，注意，标注了@VerifySignature注解的controlle层方法的入参必须存在@RequestBody，AOP中验签时才能获取到body的缓存！

  1. import cn.hutool.crypto.CryptoException;
  2. import lombok.extern.slf4j.Slf4j;
  3. import org.aspectj.lang.annotation.Aspect;
  4. import org.aspectj.lang.annotation.Before;
  5. import org.aspectj.lang.annotation.Pointcut;
  6. import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
  7. import org.springframework.stereotype.Component;
  8. import org.springframework.util.ObjectUtils;
  9. import org.springframework.web.context.request.RequestAttributes;
  10. import org.springframework.web.context.request.ServletWebRequest;
  11. import org.springframework.web.servlet.HandlerMapping;
  12. import org.springframework.web.util.ContentCachingRequestWrapper;
  13. import top.ysqorz.common.constant.BaseConstant;
  14. import top.ysqorz.config.SpringContextHolder;
  15. import top.ysqorz.config.aspect.PointCutDef;
  16. import top.ysqorz.exception.auth.AuthorizationException;
  17. import top.ysqorz.exception.param.ParamInvalidException;
  18. import top.ysqorz.signature.model.SignStatusCode;
  19. import top.ysqorz.signature.model.SignatureProps;
  20. import top.ysqorz.signature.util.CommonUtils;
  21.  
  22. import javax.annotation.Resource;
  23. import javax.servlet.http.HttpServletRequest;
  24. import java.nio.charset.StandardCharsets;
  25. import java.util.Map;
  26.  
  27. @ConditionalOnBean(SignatureProps.class)
  28. @Component
  29. @Slf4j
  30. @Aspect
  31. public class RequestSignatureAspect implements PointCutDef {
  32.     @Resource
  33.     private SignatureManager signatureManager;
  34.  
  35.     @Pointcut("@annotation(top.ysqorz.signature.enumeration.VerifySignature)")
  36.     public void annotatedMethod() {
  37.     }
  38.  
  39.     @Pointcut("@within(top.ysqorz.signature.enumeration.VerifySignature)")
  40.     public void annotatedClass() {
  41.     }
  42.  
  43.     @Before("apiMethod() && (annotatedMethod() || annotatedClass())")
  44.     public void verifySignature() {
  45.         HttpServletRequest request = SpringContextHolder.getRequest();
  46.  
  47.         String callerID = request.getParameter(BaseConstant.PARAM_CALLER_ID);
  48.         if (ObjectUtils.isEmpty(callerID)) {
  49.             throw new AuthorizationException(SignStatusCode.UNTRUSTED_CALLER); // 不受信任的调用方
  50.         }
  51.  
  52.         // 从请求头中提取签名，不存在直接驳回
  53.         String signature = request.getHeader(BaseConstant.X_REQUEST_SIGNATURE);
  54.         if (ObjectUtils.isEmpty(signature)) {
  55.             throw new ParamInvalidException(SignStatusCode.REQUEST_SIGNATURE_INVALID); // 无效签名
  56.         }
  57.  
  58.         // 提取请求参数
  59.         String requestParamsStr = extractRequestParams(request);
  60.         // 验签。验签不通过抛出业务异常
  61.         verifySignature(callerID, requestParamsStr, signature);
  62.     }
  63.  
  64.     @SuppressWarnings("unchecked")
  65.     public String extractRequestParams(HttpServletRequest request) {
  66.         // @RequestBody
  67.         String body = null;
  68.         // 验签逻辑不能放在拦截器中，因为拦截器中不能直接读取body的输入流，否则会造成后续@RequestBody的参数解析器读取不到body
  69.         // 由于body输入流只能读取一次，因此需要使用ContentCachingRequestWrapper包装请求，缓存body内容，但是该类的缓存时机是在@RequestBody的参数解析器中
  70.         // 因此满足2个条件才能使用ContentCachingRequestWrapper中的body缓存
  71.         // 1. 接口的入参必须存在@RequestBody
  72.         // 2. 读取body缓存的时机必须在@RequestBody的参数解析之后，比如说：AOP、Controller层的逻辑内。注意拦截器的时机是在参数解析之前的
  73.         if (request instanceof ContentCachingRequestWrapper) {
  74.             ContentCachingRequestWrapper requestWrapper = (ContentCachingRequestWrapper) request;
  75.             body = new String(requestWrapper.getContentAsByteArray(), StandardCharsets.UTF_8);
  76.         }
  77.  
  78.         // @RequestParam
  79.         Map<String, String[]> paramMap = request.getParameterMap();
  80.  
  81.         // @PathVariable
  82.         ServletWebRequest webRequest = new ServletWebRequest(request, null);
  83.         Map<String, String> uriTemplateVarNap = (Map<String, String>) webRequest.getAttribute(
  84.                 HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE, RequestAttributes.SCOPE_REQUEST);
  85.  
  86.         return CommonUtils.extractRequestParams(body, paramMap, uriTemplateVarNap);
  87.     }
  88.  
  89.     /**
  90.      * 验证请求参数的签名
  91.      */
  92.     public void verifySignature(String callerID, String requestParamsStr, String signature) {
  93.         try {
  94.             boolean verified = signatureManager.verifySignature(callerID, requestParamsStr, signature);
  95.             if (!verified) {
  96.                 throw new CryptoException("The signature verification result is false.");
  97.             }
  98.         } catch (Exception ex) {
  99.             log.error("Failed to verify signature", ex);
  100.             throw new AuthorizationException(SignStatusCode.REQUEST_SIGNATURE_INVALID); // 转换为业务异常抛出
  101.         }
  102.     }
  103. }
  1. import org.aspectj.lang.annotation.Pointcut;
  2.  
  3. public interface PointCutDef {
  4.     @Pointcut("execution(public * top.ysqorz..controller.*.*(..))")
  5.     default void controllerMethod() {
  6.     }
  7.  
  8.     @Pointcut("@annotation(org.springframework.web.bind.annotation.PostMapping)")
  9.     default void postMapping() {
  10.     }
  11.  
  12.     @Pointcut("@annotation(org.springframework.web.bind.annotation.GetMapping)")
  13.     default void getMapping() {
  14.     }
  15.  
  16.     @Pointcut("@annotation(org.springframework.web.bind.annotation.PutMapping)")
  17.     default void putMapping() {
  18.     }
  19.  
  20.     @Pointcut("@annotation(org.springframework.web.bind.annotation.DeleteMapping)")
  21.     default void deleteMapping() {
  22.     }
  23.  
  24.     @Pointcut("@annotation(org.springframework.web.bind.annotation.RequestMapping)")
  25.     default void requestMapping() {
  26.     }
  27.  
  28.     @Pointcut("controllerMethod() && (requestMapping() || postMapping() || getMapping() || putMapping() || deleteMapping())")
  29.     default void apiMethod() {
  30.     }
  31. }

5. 解决请求体只能读取一次

        解决方案就是包装请求，缓存请求体。SpringBoot也提供了ContentCachingRequestWrapper来解决这个问题。但是第4点中也详细描述了，由于它的缓存时机，所以它的使用有限制条件。也可以参考网上的方案，自己实现一个请求的包装类来缓存请求体

  1. import lombok.NonNull;
  2. import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
  3. import org.springframework.stereotype.Component;
  4. import org.springframework.web.filter.OncePerRequestFilter;
  5. import org.springframework.web.util.ContentCachingRequestWrapper;
  6. import top.ysqorz.signature.model.SignatureProps;
  7.  
  8. import javax.servlet.FilterChain;
  9. import javax.servlet.ServletException;
  10. import javax.servlet.http.HttpServletRequest;
  11. import javax.servlet.http.HttpServletResponse;
  12. import java.io.IOException;
  13.  
  14. @ConditionalOnBean(SignatureProps.class)
  15. @Component
  16. public class RequestCachingFilter extends OncePerRequestFilter {
  17.     /**
  18.      * This {@code doFilter} implementation stores a request attribute for
  19.      * "already filtered", proceeding without filtering again if the
  20.      * attribute is already there.
  21.      *
  22.      * @param request     request
  23.      * @param response    response
  24.      * @param filterChain filterChain
  25.      * @see #getAlreadyFilteredAttributeName
  26.      * @see #shouldNotFilter
  27.      * @see #doFilterInternal
  28.      */
  29.     @Override
  30.     protected void doFilterInternal(@NonNull HttpServletRequest request, @NonNull HttpServletResponse response, @NonNull FilterChain filterChain)
  31.             throws ServletException, IOException {
  32.         boolean isFirstRequest = !isAsyncDispatch(request);
  33.         HttpServletRequest requestWrapper = request;
  34.         if (isFirstRequest && !(request instanceof ContentCachingRequestWrapper)) {
  35.             requestWrapper = new ContentCachingRequestWrapper(request);
  36.         }
  37.         filterChain.doFilter(requestWrapper, response);
  38.     }
  39. }

注册过滤器

  1. import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
  2. import org.springframework.boot.web.servlet.FilterRegistrationBean;
  3. import org.springframework.context.annotation.Bean;
  4. import org.springframework.context.annotation.Configuration;
  5. import top.ysqorz.signature.model.SignatureProps;
  6.  
  7. @Configuration
  8. public class FilterConfig {
  9.     @ConditionalOnBean(SignatureProps.class)
  10.     @Bean
  11.     public FilterRegistrationBean<RequestCachingFilter> requestCachingFilterRegistration(
  12.             RequestCachingFilter requestCachingFilter) {
  13.         FilterRegistrationBean<RequestCachingFilter> bean = new FilterRegistrationBean<>(requestCachingFilter);
  14.         bean.setOrder(1);
  15.         return bean;
  16.     }
  17. }

6. 自定义工具类

  1. import cn.hutool.core.util.StrUtil;
  2. import org.springframework.lang.Nullable;
  3. import org.springframework.util.ObjectUtils;
  4.  
  5. import java.util.Arrays;
  6. import java.util.Map;
  7. import java.util.stream.Collectors;
  8.  
  9. public class CommonUtils {
  10.     /**
  11.      * 提取所有的请求参数，按照固定规则拼接成一个字符串
  12.      *
  13.      * @param body              post请求的请求体
  14.      * @param paramMap          路径参数(QueryString)。形如：name=zhangsan&age=18&label=A&label=B
  15.      * @param uriTemplateVarNap 路径变量(PathVariable)。形如：/{name}/{age}
  16.      * @return 所有的请求参数按照固定规则拼接成的一个字符串
  17.      */
  18.     public static String extractRequestParams(@Nullable String body, @Nullable Map<String, String[]> paramMap,
  19.                                               @Nullable Map<String, String> uriTemplateVarNap) {
  20.         // body: { userID: "xxx" }
  21.  
  22.         // 路径参数
  23.         // name=zhangsan&age=18&label=A&label=B
  24.         // => ["name=zhangsan", "age=18", "label=A,B"]
  25.         // => name=zhangsan&age=18&label=A,B
  26.         String paramStr = null;
  27.         if (!ObjectUtils.isEmpty(paramMap)) {
  28.             paramStr = paramMap.entrySet().stream()
  29.                     .sorted(Map.Entry.comparingByKey())
  30.                     .map(entry -> {
  31.                         // 拷贝一份按字典序升序排序
  32.                         String[] sortedValue = Arrays.stream(entry.getValue()).sorted().toArray(String[]::new);
  33.                         return entry.getKey() + "=" + joinStr(",", sortedValue);
  34.                     })
  35.                     .collect(Collectors.joining("&"));
  36.         }
  37.  
  38.         // 路径变量
  39.         // /{name}/{age} => /zhangsan/18 => zhangsan,18
  40.         String uriVarStr = null;
  41.         if (!ObjectUtils.isEmpty(uriTemplateVarNap)) {
  42.             uriVarStr = joinStr(",", uriTemplateVarNap.values().stream().sorted().toArray(String[]::new));
  43.         }
  44.  
  45.         // { userID: "xxx" }#name=zhangsan&age=18&label=A,B#zhangsan,18
  46.         return joinStr("#", body, paramStr, uriVarStr);
  47.     }
  48.  
  49.     /**
  50.      * 使用指定分隔符，拼接字符串
  51.      *
  52.      * @param delimiter 分隔符
  53.      * @param strs      需要拼接的多个字符串，可以为null
  54.      * @return 拼接后的新字符串
  55.      */
  56.     public static String joinStr(String delimiter, @Nullable String... strs) {
  57.         if (ObjectUtils.isEmpty(strs)) {
  58.             return StrUtil.EMPTY;
  59.         }
  60.         StringBuilder sbd = new StringBuilder();
  61.         for (int i = 0; i < strs.length; i++) {
  62.             if (ObjectUtils.isEmpty(strs[i])) {
  63.                 continue;
  64.             }
  65.             sbd.append(strs[i].trim());
  66.             if (!ObjectUtils.isEmpty(sbd) && i < strs.length - 1 && !ObjectUtils.isEmpty(strs[i + 1])) {
  67.                 sbd.append(delimiter);
  68.             }
  69.         }
  70.         return sbd.toString();
  71.     }
  72. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/你好赵伟/article/detail/157240?site
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号