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

发布时间：2025-11-05 05:33:50 来源：创站工坊 作者：数据库

​在以SpringBoot开发后台API接口时，接接口进行会存在哪些接口不安全的不安因素呢？通常如何去解决的呢？

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

准备知识点

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

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

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

是不是一个合法的开发者？

是不是一个合法的客户端？

是不是一个合法的用户?

有没有权限访问接口？

http明文传输数据？

接口重放，上文介绍的不安接口幂等

接口超时，加timestamp控制？全的签名

...

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

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

这种设计一般用在开发接口的云服务器何对安全，以确保是接接口进行一个 合法的开发者 。

以阿里云相关产品为例

从两个视角去看

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

比如oauth2协议的何对client cridential模式

grant_type参数等于client_credentials表示client credentials方式，client_id是客户端id，client_secret是客户端密钥。

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

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

grant_type参数等于password表示密码方式，client_id是客户端id，username是用户名，password是亿华云计算密码。

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

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

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

HTTP 有以下安全性问题:

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

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

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

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

例如：

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

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

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

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

严格来说不是一回事：

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

以腾讯开放平台为例，请参考 腾讯开放平台第三方应用签名参数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 {

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

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

MaprequestParameterMap = request.getParameterMap();

// @PathVariable

String[] paths = null;

ServletWebRequest webRequest = new ServletWebRequest(request, null);

MapuriTemplateVars = (Map) 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 ResponseResultmyController(@PathVariable String id

, @RequestParam String client

, @RequestBody User user) {

return ResponseResult.success(String.join(",", id, client, user.toString()));

}

body参数

如果不带X-SIGN

如果X-SIGN错误

如果X-SIGN正确

示例源码

https://github.com/realpdai/tech-pdai-spring-demos

相关文章