SpringBoot接口 - API接口有哪些不安全的因素？如何对接口进行签名？

我不是女神ヾ 2023-09-28 15:40 4阅读 0赞

在以SpringBoot开发后台API接口时，会存在哪些接口不安全的因素呢？通常如何去解决的呢？本文主要介绍API **接口有不安全的因素** 以及 **常见的保证接口安全的方式** ，重点 **实践如何对接口进行签名** 。@pdai

*  SpringBoot接口 - API接口有哪些不安全的因素？如何对接口进行签名？

### 准备知识点 ###

建议从接口整体的安全体系角度来理解，比如存在哪些不安全的因素，加密解密等知识点。

#### API接口有哪些不安全的因素？ ####

这里从体系角度，简单列举一些不安全的因素：

*  **开发者访问开放接口**
    
     *  是不是一个合法的开发者？
 *  **多客户端访问接口**
    
     *  是不是一个合法的客户端？
 *  **用户访问接口**
    
     *  是不是一个合法的用户?
     *  有没有权限访问接口？
 *  **接口传输**
    
     *  http明文传输数据？
 *  **其它方面**
    
     *  接口重放，上文介绍的接口幂等
     *  接口超时，加timestamp控制？
     *  ...

### 常见的保证接口安全的方式？ ###

针对上述接口存在的不安全因素，这里向你展示一些典型的保障接口安全的方式。

#### AccessKey&SecretKey ####

这种设计一般用在开发接口的安全，以确保是一个 **合法的开发者** 。

*  AccessKey： 开发者唯一标识
 *  SecretKey: 开发者密钥

以阿里云相关产品为例

![d3ad8698d8ca163b815d06f77c6d733d.png][]

#### 认证和授权 ####

从两个视角去看

*  第一: **认证和授权** ，认证是访问者的合法性，授权是访问者的权限分级；
 *  第二: 其中认证包括 **对客户端的认证** 以及 **对用户的认证** ；

*  **对于客户端的认证**

典型的是AppKey&AppSecret，或者ClientId&ClientSecret等

比如oauth2协议的client cridential模式

https://api.xxxx.com/token?grant_type=client_credentials&client_id=CLIENT_ID&client_secret=CLIENT_SECRET

grant\_type参数等于client\_credentials表示client credentials方式，client\_id是客户端id，client\_secret是客户端密钥。

返回token后，通过token访问其它接口。

*  **对于用户的认证和授权**

比如oauth2协议的授权码模式(authorization code)和密码模式(resource owner password credentials)

https://api.xxxx.com/token?grant_type=password&username=USERNAME&password=PASSWORD&client_id=CLIENT_ID&scope=read

grant\_type参数等于password表示密码方式，client\_id是客户端id，username是用户名，password是密码。

(PS：password模式只有在授权码模式(authorization code)不可用时才会采用，这里只是举个例子而已)

可选参数scope表示申请的权限范围。（相关开发框架可以参考spring security, Apache Shiro， [SA-Token][] 等）

#### https ####

从接口传输安全的角度，防止接口数据明文传输， 具体可以看 [这里][Link 1]

HTTP 有以下安全性问题:

*  使用明文进行通信，内容可能会被窃听；
 *  不验证通信方的身份，通信方的身份有可能遭遇伪装；
 *  无法证明报文的完整性，报文有可能遭篡改。

HTTPs 并不是新协议，而是让 HTTP 先和 SSL(Secure Sockets Layer)通信，再由 SSL 和 TCP 通信，也就是说 HTTPs 使用了隧道进行通信。

通过使用 SSL，HTTPs 具有了加密(防窃听)、认证(防伪装)和完整性保护(防篡改)。

![b0f2cde83ffbe2b6e8bae0634af486b4.jpeg][]

#### 接口签名（加密） ####

接口签名（加密），主要防止请求参数被篡改。特别是安全要求比较高的接口，比如支付领域的接口。

*  **签名的主要流程**

首先我们需要分配给客户端一个私钥用于URL签名加密，一般的签名算法如下：

1、首先对请求参数按key进行字母排序放入有序集合中（其它参数请参看后续补充部分）；

2、对排序完的数组键值对用&进行连接，形成用于加密的参数字符串；

3、在加密的参数字符串前面或者后面加上私钥，然后用加密算法进行加密，得到sign，然后随着请求接口一起传给服务器。

例如：

[https://api.xxxx.com/token?key=value&timetamp=xxxx&sign=xxxx-xxx-xxx-xxxx][https_api.xxxx.com_token_key_value_timetamp_xxxx_sign_xxxx-xxx-xxx-xxxx]

服务器端接收到请求后，用同样的算法获得服务器的sign，对比客户端的sign是否一致，如果一致请求有效；如果不一致返回指定的错误信息。

*  **补充：对什么签名？**

1.  主要包括请求参数，这是最主要的部分， 签名的目的要防止参数被篡改，就要对可能被篡改的参数签名 ；
2.  同时考虑到请求参数的来源可能是请求路径path中，请求header中，请求body中。
3.  如果对客户端分配了AppKey&AppSecret，也可加入签名计算；
4.  考虑到其它幂等，token失效等，也会将涉及的参数一并加入签名，比如timestamp，流水号nonce等（这些参数可能来源于header）

*  **补充: 签名算法？**

一般涉及这块，主要包含三点：密钥，签名算法，签名规则

1.  **密钥secret** ： 前后端约定的secret，这里要注意前端可能无法妥善保存好secret，比如SPA单页应用；
2.  **签名算法** ：也不一定要是对称加密算法，对称是反过来解析sign，这里是用同样的算法和规则计算出sign，并对比前端传过来的sign是否一致。
3.  **签名规则** ：比如多次加盐加密等；

PS：有读者会问，我们是可能从有些客户端获取密钥，算法和规则的（比如前端SPA单页应用生成的js中获取密钥，算法和规则），那么签名的意义在哪里？我认为签名是手段而不是目的，签名是加大攻击者攻击难度的一种手段，至少是可以抵挡大部分简单的攻击的，再加上其它防范方式（流水号，时间戳，token等)进一步提升攻击的难度而已。

*  **补充：签名和加密是不是一回事？**

严格来说不是一回事：

1.  签名是通过对参数按照指定的算法、规则计算出sign，最后前后端通过同样的算法计算出sign是否一致来防止参数篡改的，所以你可以看到参数是明文的，只是多加了一个计算出的sign。
2.  加密是对请求的参数加密，后端进行解密；同时有些情况下，也会对返回的response进行加密，前端进行解密；这里存在加密和解密的过程，所以思路上必然是对称加密的形式+时间戳接口时效性等。

*  **补充：签名放在哪里？**

签名可以放在请求参数中（path中，body中等），更为优雅的可以放在HEADER中，比如X-Sign（通常第三方的header参数以X-开头）

*  **补充：大厂开放平台是怎么做的呢？哪些可以借鉴？**

以腾讯开放平台为例，请参考 [腾讯开放平台第三方应用签名参数sig的说明][sig]

### 实现案例 ###

本例子采用AOP拦截自定义注解方式实现，主要看实现的思路而已(签名的目的要防止参数被篡改，就要对可能被篡改的参数签名)。@pdai

#### 定义注解 ####

package tech.pdai.springboot.api.sign.config.sign;
    
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    /**
     * @author pdai
     */
    @Target(ElementType.METHOD)
    @Retention(RetentionPolicy.RUNTIME)
    public @interface Signature {
    }

#### AOP拦截 ####

这里可以看到需要对所有用户可能修改的参数点进行按规则签名

package tech.pdai.springboot.api.sign.config.sign;
    
    import java.io.IOException;
    import java.nio.charset.StandardCharsets;
    import java.util.Map;
    import java.util.Objects;
    
    import javax.servlet.http.HttpServletRequest;
    
    import cn.hutool.core.text.CharSequenceUtil;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Before;
    import org.aspectj.lang.annotation.Pointcut;
    import org.springframework.stereotype.Component;
    import org.springframework.util.CollectionUtils;
    import org.springframework.web.context.request.RequestAttributes;
    import org.springframework.web.context.request.RequestContextHolder;
    import org.springframework.web.context.request.ServletRequestAttributes;
    import org.springframework.web.context.request.ServletWebRequest;
    import org.springframework.web.servlet.HandlerMapping;
    import org.springframework.web.util.ContentCachingRequestWrapper;
    import tech.pdai.springboot.api.sign.config.exception.BusinessException;
    import tech.pdai.springboot.api.sign.util.SignUtil;
    
    /**
     * @author pdai
     */
    @Aspect
    @Component
    public class SignAspect {
    
        /**
         * SIGN_HEADER.
         */
        private static final String SIGN_HEADER = "X-SIGN";
    
        /**
         * pointcut.
         */
        @Pointcut("execution(@tech.pdai.springboot.api.sign.config.sign.Signature * *(..))")
        private void verifySignPointCut() {
            // nothing
        }
    
        /**
         * verify sign.
         */
        @Before("verifySignPointCut()")
        public void verify() {
            HttpServletRequest request = ((ServletRequestAttributes) Objects.requireNonNull(RequestContextHolder.getRequestAttributes())).getRequest();
            String sign = request.getHeader(SIGN_HEADER);
    
            // must have sign in header
            if (CharSequenceUtil.isBlank(sign)) {
                throw new BusinessException("no signature in header: " + SIGN_HEADER);
            }
    
            // check signature
            try {
                String generatedSign = generatedSignature(request);
                if (!sign.equals(generatedSign)) {
                    throw new BusinessException("invalid signature");
                }
            } catch (Throwable throwable) {
                throw new BusinessException("invalid signature");
            }
        }
    
        private String generatedSignature(HttpServletRequest request) throws IOException {
            // @RequestBody
            String bodyParam = null;
            if (request instanceof ContentCachingRequestWrapper) {
                bodyParam = new String(((ContentCachingRequestWrapper) request).getContentAsByteArray(), StandardCharsets.UTF_8);
            }
    
            // @RequestParam
            Map<String, String[]> requestParameterMap = request.getParameterMap();
    
            // @PathVariable
            String[] paths = null;
            ServletWebRequest webRequest = new ServletWebRequest(request, null);
            Map<String, String> uriTemplateVars = (Map<String, String>) webRequest.getAttribute(
                    HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE, RequestAttributes.SCOPE_REQUEST);
            if (!CollectionUtils.isEmpty(uriTemplateVars)) {
                paths = uriTemplateVars.values().toArray(new String[0]);
            }
    
            return SignUtil.sign(bodyParam, requestParameterMap, paths);
        }
    
    }

#### Request封装 ####

package tech.pdai.springboot.api.sign.config;
    
    import java.io.IOException;
    
    import javax.servlet.FilterChain;
    import javax.servlet.ServletException;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    import lombok.NonNull;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.web.filter.OncePerRequestFilter;
    import org.springframework.web.util.ContentCachingRequestWrapper;
    
    @Slf4j
    public class RequestCachingFilter extends OncePerRequestFilter {
    
        /**
         * This {@code doFilter} implementation stores a request attribute for
         * "already filtered", proceeding without filtering again if the
         * attribute is already there.
         *
         * @param request     request
         * @param response    response
         * @param filterChain filterChain
         * @throws ServletException ServletException
         * @throws IOException      IOException
         * @see #getAlreadyFilteredAttributeName
         * @see #shouldNotFilter
         * @see #doFilterInternal
         */
        @Override
        protected void doFilterInternal(@NonNull HttpServletRequest request, @NonNull HttpServletResponse response, @NonNull FilterChain filterChain) throws ServletException, IOException {
            boolean isFirstRequest = !isAsyncDispatch(request);
            HttpServletRequest requestWrapper = request;
            if (isFirstRequest && !(request instanceof ContentCachingRequestWrapper)) {
                requestWrapper = new ContentCachingRequestWrapper(request);
            }
            try {
                filterChain.doFilter(requestWrapper, response);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

注册

package tech.pdai.springboot.api.sign.config;
    
    import org.springframework.boot.web.servlet.FilterRegistrationBean;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    @Configuration
    public class FilterConfig {
        @Bean
        public RequestCachingFilter requestCachingFilter() {
            return new RequestCachingFilter();
        }
    
        @Bean
        public FilterRegistrationBean requestCachingFilterRegistration(
                RequestCachingFilter requestCachingFilter) {
            FilterRegistrationBean bean = new FilterRegistrationBean(requestCachingFilter);
            bean.setOrder(1);
            return bean;
        }
    }

#### 实现接口 ####

package tech.pdai.springboot.api.sign.controller;
    
    import org.springframework.web.bind.annotation.PathVariable;
    import org.springframework.web.bind.annotation.PostMapping;
    import org.springframework.web.bind.annotation.RequestBody;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestParam;
    import org.springframework.web.bind.annotation.RestController;
    import tech.pdai.springboot.api.sign.config.response.ResponseResult;
    import tech.pdai.springboot.api.sign.config.sign.Signature;
    import tech.pdai.springboot.api.sign.entity.User;
    
    /**
     * @author pdai
     */
    @RestController
    @RequestMapping("user")
    public class SignTestController {
    
        @Signature
        @PostMapping("test/{id}")
        public ResponseResult<String> myController(@PathVariable String id
                , @RequestParam String client
                , @RequestBody User user) {
            return ResponseResult.success(String.join(",", id, client, user.toString()));
        }
    
    }

#### 接口测试 ####

body参数

![70bff541d4221d967844f27a4959e41d.png][]

如果不带X-SIGN

![4c8cdd445ff0a8962ab0e128ef02ec0b.png][]

如果X-SIGN错误

![221b038e8effec7ed246d6168c9b16c1.png][]

如果X-SIGN正确

![c3b5407787660cc76607e08510cf6e8e.png][]

### 示例源码 ###

[https://github.com/realpdai/tech-pdai-spring-demos][https_github.com_realpdai_tech-pdai-spring-demos]

![fba10771deaf4767ba2015543b9172ea.jpeg][]

[d3ad8698d8ca163b815d06f77c6d733d.png]: https://img-blog.csdnimg.cn/img_convert/d3ad8698d8ca163b815d06f77c6d733d.png
[SA-Token]: https://sa-token.dev33.cn/doc/index.html
[Link 1]: https://pdai.tech/md/develop/protocol/dev-protocol-http.html#%E8%AE%A4%E8%AF%81
[b0f2cde83ffbe2b6e8bae0634af486b4.jpeg]: https://img-blog.csdnimg.cn/img_convert/b0f2cde83ffbe2b6e8bae0634af486b4.jpeg
[https_api.xxxx.com_token_key_value_timetamp_xxxx_sign_xxxx-xxx-xxx-xxxx]: https://api.xxxx.com/token?key=value&timetamp=xxxx&sign=xxxx-xxx-xxx-xxxx
[sig]: https://wiki.open.qq.com/wiki/%E8%85%BE%E8%AE%AF%E5%BC%80%E6%94%BE%E5%B9%B3%E5%8F%B0%E7%AC%AC%E4%B8%89%E6%96%B9%E5%BA%94%E7%94%A8%E7%AD%BE%E5%90%8D%E5%8F%82%E6%95%B0sig%E7%9A%84%E8%AF%B4%E6%98%8E
[70bff541d4221d967844f27a4959e41d.png]: https://img-blog.csdnimg.cn/img_convert/70bff541d4221d967844f27a4959e41d.png
[4c8cdd445ff0a8962ab0e128ef02ec0b.png]: https://img-blog.csdnimg.cn/img_convert/4c8cdd445ff0a8962ab0e128ef02ec0b.png
[221b038e8effec7ed246d6168c9b16c1.png]: https://img-blog.csdnimg.cn/img_convert/221b038e8effec7ed246d6168c9b16c1.png
[c3b5407787660cc76607e08510cf6e8e.png]: https://img-blog.csdnimg.cn/img_convert/c3b5407787660cc76607e08510cf6e8e.png
[https_github.com_realpdai_tech-pdai-spring-demos]: https://github.com/realpdai/tech-pdai-spring-demos
[fba10771deaf4767ba2015543b9172ea.jpeg]: https://img-blog.csdnimg.cn/fba10771deaf4767ba2015543b9172ea.jpeg

发表评论取消回复

表情：

评论列表（有 0 条评论，4人围观）

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

相关阅读

相关 API接口安全

目前项目都是前后端分离或者有对外提供接口的需求，在这些情况下，就要考虑接口安全。如果不重视接口安全，可能导致严重的危害，例如数据盗取，服务宕机等。可能的安全问题: 1

ゝ一世哀愁。/ 2024年03月26日 14:44/ 0 赞/ 128 阅读

相关 Spring Boot 如何保证接口安全？有哪些常用的接口安全技术？

在当今互联网时代，保障接口安全已经成为了每个企业必须面对的重要问题。作为一个快速开发框架，Spring Boot 同样需要保障其接口的安全性。本文将详细介绍 Spring Bo

柔情只为你懂/ 2024年03月16日 12:55/ 0 赞/ 54 阅读

相关 Spring Boot 如何保证接口安全？有哪些常用的接口安全技术？

在当今互联网时代，保障接口安全已经成为了每个企业必须面对的重要问题。作为一个快速开发框架，Spring Boot 同样需要保障其接口的安全性。本文将详细介绍 Spring Bo

╰半夏微凉°/ 2023年10月13日 22:01/ 0 赞/ 52 阅读

相关 SpringBoot接口 - API接口有哪些不安全的因素？如何对接口进行签名？

在以SpringBoot开发后台API接口时，会存在哪些接口不安全的因素呢？通常如何去解决的呢？本文主要介绍API 接口有不安全的因素以及常见的保证接口安全的方式，重点

我不是女神ヾ/ 2023年09月28日 15:40/ 0 赞/ 5 阅读

相关 API接口签名验证

系统从外部获取数据时，通常采用API接口调用的方式来实现。请求方和接口提供方之间的通信过程，有这几个问题需要考虑： 1、请求参数是否被篡改； 2、请求来源是否合法； 3、

太过爱你忘了你带给我的痛/ 2023年01月13日 06:07/ 0 赞/ 172 阅读

相关如何保证API接口安全？

今日干货推送一、摘要在实际的业务开发过程中，我们常常会碰到需要与第三方互联网公司进行技术对接，例如支付宝支付对接、微信支付对接、高德地图查询对接等等服务，如

淩亂°似流年/ 2022年10月07日 03:54/ 0 赞/ 121 阅读

相关如何保证API接口安全？

每天早上七点三十，准时推送干货一、摘要在实际的业务开发过程中，我们常常会碰到需要与第三方互联网公司进行技术对接，例如支付宝支付对接、微信支付对接、高德地图查

系统管理员/ 2022年10月05日 11:55/ 0 赞/ 239 阅读

相关 API接口签名验证

系统从外部获取数据时，通常采用API接口调用的方式来实现。请求方和接口提供方之间的通信过程，有这几个问题需要考虑： 1、请求参数是否被篡改； 2、请求来源是否合法； 3、

Love The Way You Lie/ 2022年07月13日 00:54/ 0 赞/ 273 阅读

相关如何写出安全的API接口？接口参数加密签名设计思路

开发中经常用到接口，尤其是在面向服务的soa[架构][Link 1]中，数据交互全是用的接口。几年以前我认为，我写个接口，不向任何人告知我的接口地址，我的接口就是安全的

傷城~/ 2022年06月17日 06:46/ 0 赞/ 244 阅读

相关接口安全之签名

1. 接口请求采用https的post方式，返回信息全部采用json格式报文。 2. 请求和返回报文双方约定采用UTF-8编码，并对请求参数做URLEncoder。

淡淡的烟草味﹌/ 2022年03月15日 09:40/ 0 赞/ 321 阅读