基于Token实现开放API接口签名验证

最新推荐文章于 2024-03-13 11:16:47 发布
最新推荐文章于 2024-03-13 11:16:47 发布
阅读量9k 收藏 70
点赞数 5
分类专栏： 签名&加解密 文章标签： Java开放API接口签名验证
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42402854/article/details/121916284
版权

一、签名机制简介

1、如何保证数据在通信时的安全性

如果外部用户需要访问开放的 API接口，我们通过 HTTP Post或Get方式请求服务器，那么在写对外开放的 API接口如何保证数据的安全性的？
在开发中，为了保证数据在通信时的安全性，我们可以采用参数签名的方式来进行相关验证。所以后端在开发对外开放的 API接口时，一般会对参数进行签名来保证接口的安全性。

在设计签名算法时，主要考虑这几个问题：

  1. 请求的来源/身份是否合法？
  2. 请求参数是否被篡改？
  3. 请求是否唯一？

基于这几个问题，我们通过以下步骤来保证数据在通信时的安全性：

1.1 请求身份

通过给第三方开发者分配 AccessKey和 AccessKey Secret来验证请求者身份。

  • AccessKey ID：用于标识访问者的身份，确保唯一。也可理解为用户名
  • AccessKey Secret：用于接口加密，确保不易被穷举，生成算法不易被猜测。也可理解为用户密码

AccessKey ID和AccessKey Secret由 API服务方分配给访问者，必须严格保密。

1.2 防止篡改 - 参数签名

通过将请求的所有参数按照字母先后顺序排序后拼接再根据签名算法（比如MD5）加密得到新的字符串来保证请求参数不被篡改。

主要就是两点：

  • 构造用于签名的规范字符串
  • 将构造用于签名的规范字符串通过签名算法生成签名值

1.3 重放攻击

上面虽然解决了请求参数被篡改的隐患，但是还存在着重复使用请求参数伪造二次请求的隐患。
我们可以在请求里携带时间戳等参数来保证请求的唯一和过期或者重复的请求在指定时间内有效（可配置）。

1.3.1 timestamp+nonce方案

nonce指唯一的随机字符串，用来标识每个被签名的请求。

通过为每个请求提供一个唯一的标识符，服务器能够防止请求被多次使用（记录所有用过的 nonce以阻止它们被二次使用）。然而，对服务器来说永久存储所有接收到的nonce的代价是非常大的。可以使用 timestamp来优化 nonce的存储。

假设允许客户端和服务端最多能存在15分钟的时间差，同时追踪记录在服务端的 nonce集合。
当有新的请求进入时，

  • 首先检查携带的 timestamp是否在15分钟内，如超出时间范围，则拒绝，
  • 然后查询携带的 nonce，如存在已有集合，则拒绝。
  • 否则，记录该 nonce，并删除集合内时间戳大于15分钟的nonce（可以使用 redis的 expire，新增 nonce的同时设置它的超时失效时间为15分钟）。
1.3.2 Token&AppKey（APP）

在 APP开放API接口的设计中，由于大多数接口涉及到用户的个人信息以及产品的敏感数据，所以要对这些接口进行身份验证，为了安全起见让用户暴露的明文密码次数越少越好，然而客户端与服务器的交互在请求之间是无状态的，也就是说，当涉及到用户状态时，每次请求都要带上身份验证信息。

Token身份验证：

  • 用户登录向服务器提供认证信息（如账号和密码），服务器验证成功后返回 Token给客户端；
  • 客户端将 Token保存在本地，后续发起请求时，携带此 Token；
  • 服务器检查 Token的有效性，有效则放行，无效（Token错误或过期）则拒绝。

安全隐患：Token被劫持，伪造请求和篡改参数。《设计一个安全的对外接口》这篇也推荐阅读一下。

1.3.3 Token+AppKey签名验证

与上面开发平台的验证方式类似，为客户端分配 AppKey（密钥，用于接口加密，不参与传输），将AppKey和所有请求参数组合成源串，根据签名算法生成签名值，发送请求时将签名值一起发送给服务器验证。

这样，即使 Token被劫持，对方不知道 AppKey和签名算法，就无法伪造请求和篡改参数。
再结合上述的重发攻击解决方案，即使请求参数被劫持也无法伪造二次重复请求。

二、开放 API接口签名验证定义

通过对签名机制的了解，我们自己实现一个 开放 API接口签名验证。

我们API接口采用 TOKEN授权机制 + AppKey签名验证来实现进行交互。

  • 第三方在进行所有业务接口请求之前，必须先通过 API接口获取到正确的授权码（TOKEN）。
  • 上面AccessKey ID和AccessKey Secret可以理解为 token授权机制的用户名和密码，变量名自定义（AppKey和Code等）。
  • 签名算法中 构造用于签名的规范字符串的方式后端自定义。

1、请求

第三方在进行所有业务接口请求之前，必须先通过 API接口获取到正确的授权码（TOKEN）。
每个接口都有请求方式说明，主要使用 get、post进行数据交互。所有接口采取 utf-8字符集 发送。

  • get请求时，系统级参数和应用参数都以 get参数方式签名并发送。
  • post请求时，系统级参数以 get参数方式，应用参数都以 post参数方式签名并发送。
    具体请求参数请参见各接口说明。

2、请求参数

系统级参数：

appKey：用于标识访问者的身份,即用户名
format：响应数据格式
signMethod：签名算法
signVersion：签名版本
timestamp：请求时间
nonce：指唯一的随机字符串（比如uuid），用来标识每个被签名的请求
version：接口版本
sign：API 签名值
token：授权码（部分接口不需要，比如获取授权码。详见各接口定义）

应用级参数：见各接口规定的参数。

3、签名验签算法设计

3.1 签名生成算法

签名生成算法步骤如下：

  1. 生成构造用于签名的规范字符串（StringToSign）。
  2. 将 StringToSign字符串通过签名算法（这里使用 MD5）生成签名值，并将签名值转成为大写，然后再进行Base64编码。即得到最终 API 的签名值。
  3. 将 API 的签名值作为 sign参数的值添加到请求参数中，即完成对请求签名的过程。

HTTP请求的构造用于签名的规范字符串（StringToSign）伪代码如下：

StringToSign =
      HTTPRequestMethod + '\n' +
      CanonicalURI + '\n' +
      CanonicalQueryString + '\n' +
      Token + '\n' +
      HexEncode(Hash(RequestPayload))

参数说明：
（1）HTTPRequestMethod的值
HTTP请求方法的值，如GET、PUT、POST等。以换行符结束。

（2）CanonicalURI的值
规范URI参数（CanonicalURI）的值，以换行符结束。

规范URI，即请求资源路径，是 URI的绝对路径部分的URI编码。

格式：
根据 RFC 3986标准化URI路径，移除冗余和相对路径部分，路径中每个部分必须为URI编码。如果URI路径不以“/”结尾，则在尾部添加“/”。

（3）CanonicalQueryString的值
将 GET参数通过西面要求拼接生成规范查询字符串（CanonicalQueryString）的值，以换行符结束。
查询字符串，即查询参数或者 GET参数。如果没有查询参数，则为空字符串。
格式：
规范查询字符串需要满足以下要求：

  • 根据以下规则对每个参数名和值进行 URI编码：
    • 请勿对RFC 3986定义的任何非预留字符进行URI编码，这些字符包括：A-Z、a-z、0-9、-、_、.和~。
    • 使用%XY对所有非预留字符进行百分比编码，其中X和Y为十六进制字符（0-9和A-F）。例如，空格字符必须编码为%20，扩展UTF-8字符必须采用“%XY%ZA%BC”格式。
  • 对于每个参数，追加“URI编码的参数名称=URI编码的参数值”。如果没有参数值，则以空字符串代替，但不能省略“=”。

注意：这里我们定义了系统级参数与应用级参数，根据各接口规定的参数和 GET请求方式，合理的将系统级参数与应用级参数合并，来拼接查询字符串。

（4）Token的值
通过 API接口获取到正确的授权码（TOKEN）的值，以换行符结束。

（5）HexEncode(Hash(RequestPayload))的值
使用 SHA 256哈希函数请求正文中的 body体（RequestPayload），生成的小写哈希值。如果 RequestPayload为空或者 NULL时，默认空字符串来处理。
释义：
请求消息体。消息体需要做两层转换：HexEncode(Hash(RequestPayload))，其中：

  • Hash表示生成消息摘要的函数，当前支持SHA-256算法。
  • HexEncode表示以小写字母形式返回摘要的 Base-16编码的函数。

例如，HexEncode(“m”) 返回值为“6d”而不是“6D”。输入的每一个字节都表示为两个十六进制字符。

注意：

  • 各个参数值之间使用 换行符连接，或者你可以使用其他符合都可以。
  • 默认最后一行参数不需要添加换行符’\n’。

上面生成构造用于签名的规范字符串 参考了华为云，你也可以自定义生成规则。
示例：

stringToSign=GET
/sign-web-api/sign/getById.json/
appKey=zhaoyun&format=json&nonce=ae69c7a6-feaa-4b3d-b0a8-718d5c4d2a08&signMethod=MD5&signVersion=1.0&timestamp=1639405259585&token=3ea308fa-14c8-4d35-9dad-ac1434f4b75f&userId=1001&version=1.0
3ea308fa-14c8-4d35-9dad-ac1434f4b75f
e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855

3.2 签名验证算法（后端）

接口提供方验证接口请求是否可信，主要算法跟生成API签名的算法是一样的。

签名验证算法步骤如下：

  1. 得到客户端请求携带的 API签名值（API 的签名值），非空判断。
  2. 检查 Token授权码的有效性
  3. 检查携带的 timestamp的有效性
  4. 检查携带的 nonce的唯一性
  5. 服务器端根据请求方携带的参数（注意：不包括sign参数）通过签名生成算法生成 API签名值。
  6. 开始签名验证，如果服务器端生成的 API签名值与客户端请求的API签名是否一致的。如果一致，则请求是可信的，放行通过；否则就是不可信的，拒绝访问。

4、响应

接口以 JSON数据格式响应，响应的固定参数格式为：

{
    "success": true|false,
    "errorMessage": "失败时错误信息",
    "resultData": "返回结果集"
}

具体响应结果集请参见各接口说明。

5、其他

注意：

  • 授权码（TOKEN），授权时长为一天。
  • API接口中的地址、appKey、appKeyCode 为接口方提供，对接方请勿泄露，否则后果自付。

6、API接口参数说明

这类列举一下 获取授权码（TOKEN）接口参数说明，其他接口根据业务自己定义。

6.1 获取授权码（TOKEN）接口

获取接口授权码，在调用其他业务接口前，必须通过该接口获取授权码。

  • 请求地址：xxxx
  • 请求方式：GET
  • 请求参数：?appKey=zhaoyun&appKeySecret=zhaoyun123456
  • 响应结果：
{
    "success": true,
    "errorMessage": null,
    "resultData": {
        "token": "f834480f-2e91-405e-95e1-983d4c128e08",
        "tokenExpireTime": 1639477778147
    }
}

注意：

  • 授权码有效期为：1天。
  • 每调用一次或刷新后，旧的授权码（TOKEN）将失效。

三、Java代码实现

创建 maven 项目，下面贴一些主要代码。
在这里插入图片描述

1、自定义BodyReaderFilter

解决 springboot 对请求消息体中流不可重复读取问题。

@WebFilter(filterName = "bodyReaderFilter", urlPatterns = "/*")
public class BodyReaderFilter implements Filter {

	@Override
	public void init(FilterConfig filterConfig) throws ServletException {
		// do nothing
	}

	@Override
	public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
		ServletRequest requestWrapper = null;
		if (request instanceof HttpServletRequest) {
			// 将请求对象包装为 可重复读取流的请求对象。注意：构造好了，但是需要在拦截器中获取
			requestWrapper = new BodyReaderHttpServletRequestWrapper((HttpServletRequest) request);
		}
		if (requestWrapper == null) {
			chain.doFilter(request, response);
		} else {
			chain.doFilter(requestWrapper, response);
		}
	}

	@Override
	public void destroy() {
		// do nothing

	}
}


public class BodyReaderHttpServletRequestWrapper extends HttpServletRequestWrapper {

	private byte[] requestBody = null;// 用于将流保存下来

	public BodyReaderHttpServletRequestWrapper(HttpServletRequest request) throws IOException {
		super(request);
		requestBody = StreamUtils.copyToByteArray(request.getInputStream());
	}

	@Override
	public ServletInputStream getInputStream() throws IOException {

		final ByteArrayInputStream bais = new ByteArrayInputStream(requestBody);

		return new ServletInputStream() {

			@Override
			public int read() throws IOException {
				return bais.read();
			}

			@Override
			public boolean isFinished() {
				return false;
			}

			@Override
			public boolean isReady() {
				return false;
			}

			@Override
			public void setReadListener(ReadListener readListener) {

			}
		};
	}

	@Override
	public BufferedReader getReader() throws IOException {
		return new BufferedReader(new InputStreamReader(getInputStream()));
	}

}

2、自定义拦截器

实现 签名认证拦截。这里没有进行方法封装，步骤写的很清晰。

public class SignInterceptor implements HandlerInterceptor {
	Logger logger = LoggerFactory.getLogger(SignInterceptor.class);

	@Autowired
	private AppTokenService appTokenService;

	@Autowired
	private NonceService nonceService;

	/**
	 * 15分钟
	 */
	private static final Long FIFTEEN_MINUTES = 1000 * 60 * 15L;

	@Override
	public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
		BaseResult baseResult = new BaseResult();
		request.setCharacterEncoding("UTF-8");
		String method = request.getMethod();
		StringBuffer requestURL = request.getRequestURL();
		String canonicalURI = requestURL.substring(requestURL.indexOf(request.getContextPath()));
		if (!canonicalURI.endsWith("/")) {
			canonicalURI = canonicalURI + "/";
		}
		/**
		 * 签名验证算法步骤如下：  <br/>
		 * 1. 得到客户端请求携带的 API签名值（API 的签名值），非空判断。 <br/>
		 * 2. 检查 Token授权码的有效性  <br/>
		 * 3. 检查携带的	timestamp的有效性  <br/>
		 * 4. 检查携带的 nonce的唯一性  <br/>
		 * 5. 服务器端根据请求方携带的参数（注意：不包括sign参数）通过签名生成算法生成 API签名值。  <br/>
		 * 6. 开始签名验证，如果服务器端生成的 API签名值与客户端请求的API签名是否一致的。如果一致，则请求是可信的，放行通过；否则就是不可信的，拒绝访问。 <br/>
		 */

		// 获取请求参数
		Map<String, String[]> parameterMap = request.getParameterMap();
		// 1. 得到客户端请求携带的 API签名值（API 的签名值），非空判断。
		if (!parameterMap.containsKey("sign")) {
			baseResult.setSuccess(false);
			baseResult.setErrorMessage("签名（sign）请求参数缺失");
			responseOutByJson(response, baseResult);
			return false;
		}
		String[] signArr = parameterMap.get("sign");
		String sign = null;
		if (signArr == null || StringUtils.isBlank(sign = signArr[0])) {
			baseResult.setSuccess(false);
			baseResult.setErrorMessage("签名（sign）请求参数值为空");
			responseOutByJson(response, baseResult);
			return false;
		}

		// 2. 检查 Token授权码的有效性（获取授权码接口不判断）
		String token = "";
		if(!canonicalURI.startsWith(request.getContextPath() + "/sign/getToken.json")){
			// 如果header中不存在token，则从参数中获取token
			token = request.getHeader("token");
			if (StringUtils.isBlank(token)) {
				token = request.getParameter("token");
			}
			if (StringUtils.isBlank(token)) {
				baseResult.setSuccess(false);
				baseResult.setErrorMessage("token请求参数缺失，或者值为空");
				responseOutByJson(response, baseResult);
			}
			// 查询token信息
			AppToken appToken = appTokenService.queryByToken(token);
			if (appToken == null || appToken.getTokenExpireTime() < System.currentTimeMillis()) {
				baseResult.setSuccess(false);
				baseResult.setErrorMessage("token已过期，请重新登录");
				responseOutByJson(response, baseResult);
			}
		}

		// 3. 检查携带的 timestamp的有效性
		// 当前请求时间戳
		String timestamp = parameterMap.get("timestamp")[0];
		if (timestamp == null) {
			baseResult.setSuccess(false);
			baseResult.setErrorMessage("请求参数（timestamp）缺失，请检查后再试");
			responseOutByJson(response, baseResult);
		}
		long now = System.currentTimeMillis();
		// 判断 timestamp是否在规定时间范围内 5分钟 如超出时间范围，则拒绝
		if (now - Long.parseLong(timestamp) >= FIFTEEN_MINUTES) {
			baseResult.setSuccess(false);
			baseResult.setErrorMessage("请求超时");
			responseOutByJson(response, baseResult);
		}

		// 4. 检查携带的 nonce的唯一性
		// 查询携带的随机字符串nonce
		String nonce = parameterMap.get("nonce")[0];
		if (nonce == null) {
			baseResult.setSuccess(false);
			baseResult.setErrorMessage("请求参数（nonce）缺失，请检查后再试");
			responseOutByJson(response, baseResult);
		}
		// 从缓存中查找是否有相同请求,，如存在已有集合，则拒绝
		if (nonceService.isExist(nonce)) {
			baseResult.setSuccess(false);
			baseResult.setErrorMessage("nonce已存在，请求错误，请检查后再试");
			responseOutByJson(response, baseResult);
		} else {
			// 否则，记录该nonce，并删除集合内时间戳大于5分钟的nonce，新增nonce的同时设置它的超时失效时间为5分钟
			nonceService.saveNonceAndDeleteExpireTime(nonce);
		}

		// 5. 服务器端根据请求方携带的参数（注意：不包括sign参数）通过签名生成算法生成 API签名值。
		// 获取请求消息体
		String requestBody = getRequestBody(request);
		Map<String, String> getParameterMap = parameterMap.entrySet().stream().filter(m -> !"sign".equals(m.getKey()))
				.collect(Collectors.toMap(m -> m.getKey(), m -> m.getValue()[0], (o, n) -> n));
		getParameterMap.put("token", token);
		// 生成sign，进行签名认证
		String genSign = SignUtils.generateSign(method, canonicalURI, getParameterMap, token, requestBody);
		logger.error("----preHandle---- -> sign={}，genSign={}", sign, genSign);
		if (!sign.equals(genSign)) {
			baseResult.setSuccess(false);
			baseResult.setErrorMessage("签名（sign）不匹配， 签名验证失败");
			responseOutByJson(response, baseResult);
			return false;
		}
		return true;
	}

	/**
	 * 获取请求消息体
	 *
	 * @param request
	 * @return
	 */
	private String getRequestBody(HttpServletRequest request) {
		StringBuilder sb = new StringBuilder("");
		try (BufferedReader br = request.getReader()) {
			String str;
			while ((str = br.readLine()) != null) {
				sb.append(str);
			}
		} catch (IOException e) {
			logger.error("系统异常 -> 获取请求消息体参数异常。e={}", e.getMessage());
		}
		return sb.toString();
	}

	/**
	 * 响应输出json
	 * 
	 * @param response
	 * @param baseResult
	 */
	private void responseOutByJson(HttpServletResponse response, BaseResult baseResult) {
		response.setCharacterEncoding("UTF-8");
		response.setContentType("application/json");
		try (PrintWriter out = response.getWriter()) {
			out.print(JSON.toJSONString(baseResult, SerializerFeature.WriteNonStringValueAsString, SerializerFeature.WriteMapNullValue));
		} catch (IOException e) {
			logger.error("系统异常 -> 响应异常。e={}", e.getMessage());
		}
	}
}

3、签名算法工具类

public class SignUtils {
	private static final Logger logger = LoggerFactory.getLogger(SignUtils.class);

	private SignUtils() {
	}

	/**
	 * 生成签名
	 * 
	 * @param httpRequestMethod
	 * @param canonicalURI
	 * @param getParamterMap
	 * @param token
	 * @param requestBodyStr
	 * @return
	 */
	public static String generateSign(String httpRequestMethod, String canonicalURI, Map<String, String> getParamterMap, String token, String requestBodyStr) {

		/**
		 * 签名生成算法步骤如下：  <br/>
		 * 1. 生成构造用于签名的规范字符串（StringToSign）。  <br/>
		 * 2. 将 StringToSign字符串通过签名算法（这里使用 MD5）生成签名值，并将签名值转成为大写，然后再进行Base64编码。即得到最终 API的签名值。 <br/>
		 *
		 */
		String stringToSign = structureStringToSign(httpRequestMethod, canonicalURI, getParamterMap, token, requestBodyStr);
		// MD5后转成大写即为最终签名结果。
		String sign = Md5Utils.MD5Upper(stringToSign).toUpperCase();
		logger.info("签名算法，生成 API的签名值 -> sign={}", sign);
		return sign;
	}

	/**
	 * 构造用于签名的规范字符串
	 *
	 * @param httpRequestMethod
	 * @param canonicalURI
	 * @param getParamterMap
	 * @param token
	 * @param requestBodyStr
	 * @return
	 */
	private static String structureStringToSign(String httpRequestMethod, String canonicalURI, Map<String, String> getParamterMap, String token, String requestBodyStr) {
		/**
		 * StringToSign = <br/>
		 *       HTTPRequestMethod + '\n' +  <br/>
		 *       CanonicalURI + '\n' +  <br/>
		 *       CanonicalQueryString + '\n' +  <br/>
		 *       Token + '\n' +  <br/>
		 *       HexEncode(Hash(RequestPayload))  <br/>
		 */
		String canonicalQueryString = spliceCanonicalQueryString(getParamterMap);
		// 根据RFC 3986标准化URI路径，移除冗余和相对路径部分，路径中每个部分必须为URI编码。如果URI路径不以“/”结尾，则在尾部添加“/”。
		if (!canonicalURI.endsWith("/")) {
			canonicalURI = canonicalURI + "/";
		}
		// 如果请求消息体为null，直接使用空字符串""。SHA256 哈希，并小写
		String sha256RequestBody = sha256RequestBody = Sha256Utils.getSHA256(StringUtils.isBlank(requestBodyStr) ? "" : requestBodyStr).toLowerCase();
		;
		// 构建规范字符串
		StringBuffer stringToSign = new StringBuffer("");
		stringToSign.append(httpRequestMethod.toUpperCase()).append("\n")
				.append(canonicalURI).append("\n")
				.append(canonicalQueryString).append("\n")
				.append(token).append("\n")
				.append(sha256RequestBody);
		logger.info("生成构造用于签名的规范字符串 -> canonicalQueryString={}, stringToSign={}", canonicalQueryString, stringToSign);
		return stringToSign.toString();
	}

	/**
	 * 获取拼接生成规范查询字符串，不带sign
	 *
	 * @param getParamterMap
	 *            - 系统级参数与应用级参数合并之后的集合
	 * @return
	 */
	public static String spliceCanonicalQueryString(Map<String, String> getParamterMap) {
		if (null == getParamterMap) {
			return null;
		}
		// 字典排序
		TreeMap<String, String> sortMap = new TreeMap<>(getParamterMap);
		return spliceParams(sortMap);
	}

	/**
	 * 拼接参数
	 *
	 * @param treeMap
	 * @return
	 */
	private static String spliceParams(TreeMap<String, String> treeMap) {
		if (null == treeMap) {
			return null;
		}

		StringBuilder paramStr = new StringBuilder();
		/**
		 * 去除首尾空格，符合URL编码的编码规则
		 */
		treeMap.forEach((key, value) -> {
			key = key.trim();
			key = URLEncoder.encode(key, StandardCharsets.UTF_8).replace("*", "%2A").replace("+", "%20").replace("%7E", "~");
			value = StringUtils.isBlank(value) ? "" : value.trim();
			value = URLEncoder.encode(value, StandardCharsets.UTF_8).replace("*", "%2A").replace("+", "%20").replace("%7E", "~");
			paramStr.append("&").append(key).append("=").append(value);
		});

		// 去掉第一个&
		return paramStr.substring(1);
	}

}

4、配置类

@Configuration
public class WebConfig implements WebMvcConfigurer {

	@Bean
	public SignInterceptor signInterceptor() {
		return new SignInterceptor();
	}

	/**
	 * 添加拦截器 https://blog.csdn.net/qq_42240485/article/details/104900009
	 * 
	 * @param registry
	 */
	@Override
	public void addInterceptors(InterceptorRegistry registry) {
		registry.addInterceptor(signInterceptor())
				.addPathPatterns("/sign/**")
				.excludePathPatterns("/login", "/", "/index");

	}

	/**
	 * 添加过滤器
	 * 
	 * @return
	 */
	@Bean
	public FilterRegistrationBean<BodyReaderFilter> Filters() {
		FilterRegistrationBean<BodyReaderFilter> registrationBean = new FilterRegistrationBean<BodyReaderFilter>();
		registrationBean.setFilter(new BodyReaderFilter());
		registrationBean.addUrlPatterns("/*");
		registrationBean.setName("bodyReaderFilter");
		return registrationBean;
	}

}

参考文章：

– 求知若饥，虚心若愚。

Charge8
关注
  • 5
    点赞
  • 踩
  • 70
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
WebApi 使用TOKEN+签名验证
10-17
WebApi安全性 使用TOKEN+签名验证
WEB API 接口签名验证入门与实战课程
06-21
通过对API接口编写与请求过程的分析认识到接口请求中的安全问题，并利用签名验证解决这些问题 这些 API数据传输各种安全问题包括： 1、如何接口请求这的合法性 2、如何保证登陆的安全性 3、如何保证请求的参数不被篡改以及请求的时效性 本套课程我们采用了签名验证算法解决了上述问题以及手把手教你如何实现编码。
API key 和 token 有什么区别？
最新发布
Jernnifer_mao的博客
03-13 985
我们可以通过以下定义来区分 API key 和 token。API key — 通过代码调用 API 时提供的值，用于识别和授权调用者。它旨在以编程方式使用，通常是一长串字母和数字。token — 代表用户会话或特定权限的一段数据。供个人用户在有限的时间内使用。API key 和 token 各有优缺点。一个并不比另一个更好。在决定要应用哪种身份验证机制时，请结合你的应用场景来进行选择。如果是用在用户会话的身份验证场景时，可以使用 token。
Springboot+vue中实现用户登陆时通过token验证的demo
m0_74417628的博客
09-15 1562
学习了http://t.csdn.cn/FSPqU后实现的Springboot+vue登陆时的token验证的demo
WebApi Token+ 数字签名认证源码
04-10
代码包括客户端和服务器，前端jquery，后端C#代码。绕过验证与拦截器验证token和数字证书
PHP开发api接口安全验证操作实例详解
01-20
本文实例讲述了PHP开发api接口安全验证操作.分享给大家供大家参考，具体如下： php的api接口 在PHP的开发工作中，对API接口开发不会陌生，后端人员写好接口后，前台就可以通过链接获取接口提供的数据，而返回的数据一般分为两种情况，xml和json, 在这个过程中，服务器并不知道，请求的来源是什么，有可能是别人非法调用我们的接口，获取数据，因此就要使用安全验证来屏蔽某些调用。 验证原理示意图 原理 从图中可以看得很清楚，前台想要调用接口，需要使用几个参数生成签名。 ● 时间戳：当前时间 ● 随机数：随机生成的随机数 ● 口令：前后台开发时，一个双方都知道的标识，相当于暗号 ● 算法规则
API接口签名验证
qq_25046827的博客
03-01 4437
但是这样的验证方式存在有一定的问题，如果token被泄露被他人获取，那么就会有非法请求的风险。只需要服务端与客户端约定一套密钥，客户端在发送请求时拼接上私钥后使用单向加密算法进行加密，服务端收到后使用相同的私钥和加密算法进行加密后验证是否与前端客户端传递的值相同。以上方式虽然解决了非法用户请求和请求参数被篡改的问题，但是还存在着重复使用请求参数伪造二次请求的隐患。为了防止这种情况的发生，我们验证接收到的数据与客户端发送的数据一致，且让接口只能被客户端请求。
开发API接口的安全验证：token，参数签名，时间戳
热门推荐
何哥的博客
03-18 1万+
前言：服务端与前端对接的API接口，如果被第三方抓包并进行恶意篡改参数，可能会导致数据泄露和篡改数据，下面主要围绕token，签名，时间戳，三个部分来保证API接口的安全性。 参考链接，致敬前辈： 开放API接口签名验证，让你的接口从此不再裸奔 API接口的安全设计验证：ticket，签名，时间戳 1.用户成功登陆站点后，服务器会返回一个token，用户的任何操作都必须带了这个参数，可以将这个参数直接放到header里。 2.客户端用需要发送的参数和token生成一个签名sign，作为参
简单的token用户登录实现，接口权限校验
萌兔兔MMQ！！
09-16 1559
不想用redis管理也可以放在内存中，基本思路就是每次登录成功新建一个map，key是token,value是临时类，里面有user的实体和当前保存时的毫秒值，然后将map放入list中，每次请求对比有无这个token(key),然后拿出user即可，再建立一个定时任务，定时对比当前系统时间和临时类中的毫秒值，如果超出规定的时间就删除当前map，切记删除后break，否则会报空指针异常。# redis数据库索引(默认为0)，我们使用索引为6的数据库，避免和其他数据库冲突。# redis连接池配置。
接口测试中的Token鉴权（Postman中Token的获取和引用）
apex_eixl的博客
03-27 2207
在进行一些数据传递之前，要核对暗号。在web领域，基于Token的身份验证非常常见，如很多操作是在登录之后进行的，用户第一次登录成功后会返回一个Token，后续的操作带上这个token来请求数据即可，不用再带上用户名和密码。一般情况下，每次登录返回的token值都是变化的，这种情况下，可以将读取到的Token值设为环境变量/全局变量，token变化，环境变量读取的值也会变化。在需要引用token的接口的请求Header中添加KEY：Authorization，值为你设置的环境变量{{token}}
.net core API 项目token验证（JWT方法）
gengjia_的博客
12-02 5074
API token验证笔记
WebApi安全性 使用TOKEN+签名验证.zip
07-19
WebApi token+签名认证的主要原理是：1.做一个认证服务，提供一个认证的webapi，用户先访问它获取对应的token 2.用户拿着相应的token以及请求的参数和服务器端提供的签名算法计算出签名后再去访问指定的api 　　　　　　　　　　　　　　 3.服务器端每次接收到请求就获取对应用户的token和请求参数，服务器端再次计算签名和客户端签名做对比，如果验证通过则正常访问相应的api，验证失败则返回具体的失败信息
Vue項目中实现用户登录及 token 验证
wxm_CXZL的博客
05-08 1298
在前后端完全分离的情况下，Vue项目中实现token验证详细操作说明
前后端分离后，使用token进行接口调用验证处理
IT冲冲冲
07-27 8442
目前项目的发展趋势是前后端分离，前端使用vue、React、angular等技术，后端提供接口。 这种方式将后端开发人员从JSP（HTML、css、JS）中解放出来，更专注于后台逻辑的实现。但前后端分离后，由于后端接口是无状态的，那用户信息等敏感数据如何拿到呢？ 可以使用token（令牌）机制进行实现，思路如下： 前端第一次登录后，后端使用userid、时间戳等信息组成字符串，然后使用A...
移动端与PHP服务端接口通信流程设计(基础版)
weixin_30825199的博客
05-29 787
转载自：http://blog.snsgou.com/post-766.html --->非开放性平台 --->公司内部产品 接口特点汇总： 1、因为是非开放性的，所以所有的接口都是封闭的，只对公司内部的产品有效； 2、因为是非开放性的，所以OAuth那套协议是行不通的，因为没有中间用户的授权过程； 3、有点接口需要用户登录...
四、【Django】基于Jwt的token认证（登录接口）
Ataoker的博客
07-18 2654
django 使用jwt token的东西来进行认证
postman测试带token验证的接口，解决token为空问题
青及笄经验分享
10-20 1万+
postman测试带token验证的接口，解决token为空问题
简单前后端分离的token验证流程
weixin_51751186的博客
04-15 9873
文章目录前言一、后端流程0 实体类user和DTO类UserDTO1 引入jwt依赖2 编写jwt工具类3 前后端token验证流程1 后端登陆接口和数据处理，返给前端token1controlle层2 service层次(这里的getone函数是mybatis-plus service层函数，因为结合使用了mybatis-plus所以dao层函数不用定义了)2 后端自定义jwt拦截器 并注册拦截器1 自定义jwt拦截器2 注册jwt拦截器（记得放行登陆接口）一.五 设定统一返回类后后端返给前端的信息数
什么是API Token？
par@ish的博客
12-11 1674
API令牌是一种用于访问和验证API（应用程序编程接口）的安全凭证。它是一个字符串，用于识别和授权应用程序或用户访问特定的API服务或资源。API令牌可以是访问令牌（Access Token）或密钥（API Key）。Access Token通常是通过身份验证协议（比如OAuth）获取的，用于访问受保护的资源。API Key则是直接向API服务提供方获取的密钥，用于标识应用程序或用户。
.net core webapi怎样配置token验证
08-17
### 回答1： 在 .NET Core Web API 中进行 Token 验证通常涉及以下步骤： 1. 安装 Microsoft.AspNetCore.Authentication.JwtBearer 包。 2. 在 Startup.cs 文件的 ConfigureServices() 方法中添加身份验证服务，包括 JWTBearerOptions 配置。 3. 在 Startup.cs 文件的 Configure() 方法中启用身份验证中间件。 以下是一个基本的示例： ```csharp using Microsoft.AspNetCore.Authentication.JwtBearer; using Microsoft.IdentityModel.Tokens; using System.Text; public void ConfigureServices(IServiceCollection services) { // 配置身份验证服务 services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme) .AddJwtBearer(options => { options.TokenValidationParameters = new TokenValidationParameters { ValidateIssuer = true, ValidateAudience = true, ValidateLifetime = true, ValidateIssuerSigningKey = true, ValidIssuer = Configuration["Jwt:Issuer"], ValidAudience = Configuration["Jwt:Audience"], IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(Configuration["Jwt:SecretKey"])) }; }); // 其他服务注册... } public void Configure(IApplicationBuilder app, IWebHostEnvironment env) { // 启用身份验证中间件 app.UseAuthentication(); // 其他中间件注册... } ``` 上述代码中，我们使用了 `AddAuthentication()` 方法来配置身份验证服务，并指定了 JWTBearerDefaults.AuthenticationScheme 作为默认身份验证方案。 接着，我们使用 `AddJwtBearer()` 方法来配置 JWTBearerOptions，其中 `TokenValidationParameters` 属性用于指定 Token 验证参数，例如验证发行者、受众、过期时间、签名密钥等。 最后，在 Configure() 方法中，我们调用 `UseAuthentication()` 方法来启用身份验证中间件，以确保每个请求都进行身份验证。 ### 回答2： 在.NET Core Web API中配置Token验证，可以按照以下步骤进行操作： 1. 添加NuGet包：在项目中添加Microsoft.AspNetCore.Authentication和Microsoft.AspNetCore.Authentication.JwtBearer两个NuGet包。 2. 配置认证服务：在Startup.cs文件的ConfigureServices方法中添加以下代码，以启用Bearer令牌验证： ``` services.AddAuthentication(options => { options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme; options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme; }) .AddJwtBearer(options => { options.TokenValidationParameters = new TokenValidationParameters { ValidateIssuer = true, // 验证发行人 ValidateAudience = true, // 验证受众 ValidateLifetime = true, // 验证生命周期 ValidateIssuerSigningKey = true, // 验证颁发的签名密钥 ValidIssuer = "your_issuer", // 设置发行人 ValidAudience = "your_audience", // 设置受众 IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes("your_secret_key")) // 设置签名密钥 }; }); ``` 3. 配置授权：在Startup.cs文件的Configure方法中添加以下代码，以启用授权中间件： ``` app.UseAuthentication(); app.UseAuthorization(); ``` 4. 添加[Authorize]特性：在需要验证Token的Controller或Action上添加[Authorize]特性。 现在，当客户端请求受保护的Controller或Action时，将自动检查请求中的Token是否有效。如果Token验证失败，将返回401 Unauthorized状态码。如果验证成功，则可以继续处理请求。 ### 回答3： 在.NET Core WebAPI中配置Token验证主要涉及以下几个步骤： 1. 导入所需的包：首先，需要在`Startup.cs`文件中的`ConfigureServices`方法中导入所需的包。使用`Microsoft.AspNetCore.Authentication.JwtBearer`包来配置JWT验证。 2. 配置认证服务：在`ConfigureServices`方法中使用`services.AddAuthentication`来添加认证服务，并指定默认的身份验证方案。例如： ```csharp services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme) .AddJwtBearer(options => { options.RequireHttpsMetadata = false; // 是否要求HTTPS options.TokenValidationParameters = new TokenValidationParameters { ValidateIssuer = true, // 验证发行者 ValidateAudience = true, // 验证接收者 ValidateLifetime = true, // 验证令牌有效期 ValidateIssuerSigningKey = true, // 验证签名 ValidIssuer = "your_issuer", ValidAudience = "your_audience", IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes("your_secret_key")) }; }); ``` 在上述代码中，可以根据自己的需求调整参数值，如验证发行者、接收者、令牌有效期、签名等。 3. 应用认证中间件：在`Configure`方法中，使用`app.UseAuthentication()`来应用认证中间件。确保此代码位于路由中间件之前。例如： ```csharp app.UseAuthentication(); app.UseRouting(); app.UseAuthorization(); ``` 4. 使用`Authorize`特性：在需要进行Token验证的Controller或Action上，可以使用`Authorize`特性来标记，以进行访问控制。例如： ```csharp [Authorize] public class MyController : ControllerBase { // ... } ``` 5. 在请求中包含Token：最后，在发送请求时，需要在请求头中包含Bearer Token，以进行验证。例如： ``` Authorization: Bearer your_token ``` 通过以上配置，就可以在.NET Core WebAPI中实现Token验证。这样，当请求到达API时，API会验证Token的有效性，并对请求进行授权控制，确保只有拥有有效Token的用户可以访问受保护的资源。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值