＜优化接口设计的思路＞：接口安全

前言

一、接口安全的方式

1. 身份认证，鉴别客户端

2. 请求过程鉴权，防止请求被篡改

3. 访问控制，即控制客户端对API的访问权限

前言

某家电商平台上，用户可以通过客户端发起购物请求，并对所选商品进行下单、支付等操作。

为了保障系统的安全性和用户隐私，该电商平台采取了一系列安全措施，包括身份认证、请求过程鉴权和访问控制等三个阶段的验证。

第一阶段是身份认证，鉴别客户端的身份。这一阶段可以采用多种方式进行身份验证，如HTTP基本认证、Token认证，和OAuth2认证等。在具体实践中，我们可以在客户端请求接口的时候，一并提交用于身份认证的Token信息，接口服务器可以通过相关的算法验证Token合法性并拒绝非法请求。同时，Token的生成和管理可利用第三方模块，如jsonwebtoken等来实现。

第二阶段是请求过程鉴权，防止请求被篡改。针对您提供的拉起第三方支付的业务场景，可以在客户端请求前提前生成一份用于防伪验签的随机字符串或者签名，然后将该随机字符串或者签名等信息携带在接口请求参数中，客户端请求接口时，后端可以将请求参数中的随机字符串或者签名等信息重新计算一遍，以判断请求是否被篡改。在具体实现中，我们可以需要将关键数据通过客户端的公钥或者密钥进行加密后再发送到后端服务器上，以保证隐私数据不会被泄露。

第三阶段是访问控制，即控制客户端对API的访问权限。在具体实践中，我们可以利用RBAC模型对访问API的权限进行控制。RBAC模型的基本思想是将访问API的用户分为多个角色，然后对每个角色授予对API的访问权限。当用户访问API时，后端服务器会根据该用户被授予的角色来判断用户是否有权访问该API，如果没有授权访问权限，则服务器会拒绝请求。

以下是Java版本的接口验签示例代码：

import java.security.MessageDigest;
import java.util.Map;

import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class PaymentController {
private final String APP_SECRET = "xxx";

@RequestMapping("/third_party_payment")
@ResponseBody
public String third_party_payment(@RequestParam Map<String, String> params) {
String appId = params.get("app_id");
String timestamp = params.get("timestamp");
String paymentAmount = params.get("payment_amount");
String sign = params.get("sign");

// 进行参数合法性校验
if (StringUtils.isEmpty(appId) || StringUtils.isEmpty(timestamp) || StringUtils.isEmpty(paymentAmount)
|| StringUtils.isEmpty(sign)) {
return "{"code":400,"msg":"参数不完整。"}";
}

// 进行接口鉴权校验
String data = String.format("%s%s%s%s", appId, timestamp, paymentAmount, APP_SECRET);
String md5Sign = MD5(data);
if (!md5Sign.equals(sign)) {
return "{"code":400,"msg":"签名不正确。"}";
}
// 成功的业务逻辑处理
return "{"code":200,"msg":"ok"}";
}

/**
* 计算MD5值
*/
private String MD5(String data) {
try {
MessageDigest md = MessageDigest.getInstance("MD5");
byte[] bytes = md.digest(data.getBytes("UTF-8"));
StringBuilder sb = new StringBuilder();
for (byte b : bytes) {
String hex = Integer.toHexString(b & 0xff);
if (hex.length() == 1) {
sb.append("0");
}
sb.append(hex);
}
return sb.toString();
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}

在该实现中，我们使用SpringBoot作为应用开发框架，通过RESTful API的方式提供第三方支付接口服务。接口请求时需要提供app_id、timestamp、payment_amount和sign四个参数，其中sign参数是通过对前三个参数进行加密生成的。我们使用了MD5算法对前三个参数和app_secret进行加密，生成sign参数。请求到达服务端后，我们可以通过鉴别请求参数的合法性来进行身份认证和请求过程鉴权，接着可以使用MD5算法对请求参数进行处理，判断请求是否被篡改。最后，我们对用户的请求进行业务逻辑处理，并返回对应的结果。

总的来说，该实现使用了常见的开发框架和加密算法，实现了基本的接口验策略。在实际应用中，需要结合具体业务场景进行优化和改进，以保证接口的安全性、可靠性和高效性。

常见的案例：

输入验证

输入验证是保证接口安全性的重要措施之一，可以使用正则表达式或其他验证方式对请求参数进行验证，确保数据的完整性和正确性。以下是一个简单的示例代码：

@RequestMapping(value = "/login", method = RequestMethod.POST)

public ResponseEntity<String> login(@RequestParam("username") String username,

@RequestParam("password") String password) {

// 验证用户名是否合法

if (!username.matches("^[a-zA-Z0-9]*$")) {

return new ResponseEntity<>("Invalid username", HttpStatus.BAD_REQUEST);

}

// 验证密码是否合法

if (!password.matches("^[a-zA-Z0-9]*$")) {

return new ResponseEntity<>("Invalid password", HttpStatus.BAD_REQUEST);

}

// TODO: 根据具体业务逻辑进行其他验证

return new ResponseEntity<>("Login success", HttpStatus.OK);

}

复制代码

防止SQL注入

SQL注入是常见的攻击手段之一，可以通过参数化查询或预编译语句来防止SQL注入攻击。以下是一个简单的示例代码：

@RequestMapping(value = "/users", method = RequestMethod.GET)

public ResponseEntity<List<User>> getUsers(@RequestParam("name") String name) {

String sql = "SELECT * FROM user WHERE name = ?";

List<User> users = jdbcTemplate.query(sql, new Object[]{name}, new BeanPropertyRowMapper<>(User.class));

return new ResponseEntity<>(users, HttpStatus.OK);

}

复制代码

防止XSS攻击

XSS攻击是指攻击者在页面中注入恶意脚本，可以通过对特殊字符进行转义或使用HTML5的Content Security Policy来防止XSS攻击。以下是一个简单的示例代码：

@RequestMapping(value = "/search", method = RequestMethod.GET)

public ResponseEntity<String> search(@RequestParam("keyword") String keyword) {

// 对特殊字符进行转义

keyword = HtmlUtils.htmlEscape(keyword);

// TODO: 根据具体业务逻辑进行查询

return new ResponseEntity<>(result, HttpStatus.OK);

}

复制代码

4. 防止CSRF攻击

CSRF攻击是指攻击者利用用户的登录状态发起恶意请求，可以通过在请求中添加随机生成的CSRF令牌来防止CSRF攻击。以下是一个简单的示例代码：

@RequestMapping(value = "/transfer", method = RequestMethod.POST)

public ResponseEntity<String> transfer(@RequestParam("from") String from,

@RequestParam("to") String to,

@RequestParam("amount") BigDecimal amount,

@RequestParam("csrfToken") String csrfToken,

HttpServletRequest request) {

// 验证CSRF令牌

HttpSession session = request.getSession();

String sessionToken = (String) session.getAttribute("csrfToken");

if (!csrfToken.equals(sessionToken)) {

return new ResponseEntity<>("Invalid CSRF token", HttpStatus.BAD_REQUEST);

}

// TODO: 根据具体业务逻辑进行转账

return new ResponseEntity<>("Transfer success", HttpStatus.OK);

}

@RequestMapping(value = "/getCSRFToken", method = RequestMethod.GET)

public ResponseEntity<String> getCSRFToken(HttpServletRequest request) {

// 生成随机的CSRF令牌

String csrfToken = UUID.randomUUID().toString();

HttpSession session = request.getSession();

session.setAttribute("csrfToken", csrfToken);

return new ResponseEntity<>(csrfToken, HttpStatus.OK);

}

复制代码

5. 验证UID是否是登录UID

验证UID是否是登录UID也是保证接口安全性的重要措施之一。在实际开发中，我们通常会使用会话机制（session）来保存用户的登录状态。对于需要验证UID的接口，我们可以在会话中保存用户的UID，并在接口调用时进行验证，确保用户只能访问自己的数据。以下是一个简单的示例代码：

@RequestMapping(value = "/getUserInfo", method = RequestMethod.GET)

public ResponseEntity<UserInfo> getUserInfo(@RequestParam("uid") Long uid, HttpSession session) {

// 验证用户是否登录

Long loginUid = (Long) session.getAttribute("uid");

if (loginUid == null) {

return new ResponseEntity<>(HttpStatus.UNAUTHORIZED);

}

// 验证UID是否是登录UID

if (!uid.equals(loginUid)) {

return new ResponseEntity<>(HttpStatus.FORBIDDEN);

}

// TODO: 根据UID获取用户信息

UserInfo userInfo = userService.getUserInfo(uid);

return new ResponseEntity<>(userInfo, HttpStatus.OK);

}

复制代码

在实际开发中，以上安全措施可能只是保障接口安全的基础，还需要根据具体的业务场景和安全需求进行进一步的加固。以下是一些额外的安全措施：

HTTPS：采用HTTPS协议保障接口传输的安全性，防止中间人攻击和数据泄露。

API密钥：为每个客户端分配唯一的API密钥，防止未经授权的访问。

访问频率限制：限制接口访问的频率，防止恶意攻击和DDoS攻击。

日志记录：记录接口的访问日志和异常日志，方便追踪和排查安全问题。

安全审计：定期对接口进行安全审计，发现可能存在的安全漏洞并及时修复。

防火墙：在服务器上配置防火墙，限制对接口的访问，防止未经授权的访问和攻击。

综上所述，保障接口安全需要采取一系列的安全措施，包括输入验证、防止SQL注入、防止XSS攻击、防止CSRF攻击、验证UID是否是登录UID等。除此之外，还可以采取其他的安全措施来进一步加固接口的安全性，确保接口的稳定和安全。

一、为什么要保证接口安全

在我们日常开发中,存在一些接口是敏感且重要的,比如充值接口,如果在你调用充值接口的时候被别人抓包了,然后就可以修改充值的金额,本来充值10元可以改成充值10w,产生重大生产问题,再或者说被被人抓包了,别人可以不限制的调用该充值10元的接口,调用几万次,也是会导致重大问题,那么我们该如何保证接口安全呢?

二、接口安全的几种方式

2.1 数据参数合法性校验

接口数据的安全性保证，还需要我们的系统，有个数据合法性校验，简单来说就是参数校验，比如身份证长度，手机号长度，是否是数字等等

2.2 token授权认证方式

一般我们系统都会使用token鉴权登陆校验用户登陆状态和用户权限,访问接口前先校验token的合法性

2.3 数据加密,防止报文明文传输

说到数据加密,我们不难想到使用HTTPS进行传输,HTTPS使用了RSA和AES加密的方式保证了数据传输中的安全问题,具体的HTTPS的加密原理,请看HTTPS原理

数据在传输过程中被加密了，理论上，即使被抓包，数据也不会被篡改。但是https不是绝对安全的哦。还有一个点：https加密的部分只是在外网，然后有很多服务是内网相互跳转的，签名验证也可以在这里保证不被中间人篡改，所以一般转账类安全性要求高的接口开发，都需要加签验签

2.4 签名验证

https虽然保证了在外网上数据不会被篡改,但是不能保证在内网中数据篡改的风险,所以需要有签名验证的环节

客户端把参数以特定顺序进行md5加密形成签名sign,一并同参数传递到服务端

服务端接收到签名和参数,也以一定的顺序对参数进行md5加密,对比传递来的sign判断是否是否被篡改

这样做的好处就是,在数据传输过程中,可以保证数据不会被篡改,如果篡改了的话sign就会不一致,验证不通过

但是这仅仅只是解决了篡改问题,那如果我拿到请求后不修改参数,原样数据多次调用,还是会产生问题,这时候就需要增加防重放功能

2.5 timestamp+nonce方案防止重放攻击

timestamp是时间戳超时机制,当一个请求超过该时间后,则认定为该请求失效,需要重新发送请求,默认60s,但是如果在60s内多次调用岂不是也会导致问题?

通常来说,从抓包到重放的时间绝对不止60s,为了避免此类问题发生,我们可以在客户端发送请求的时候随机产生一个nonce随机数

nonce令牌是一个随机数,每次请求后都会存入redis,过期时间60s,这样就没个请求只能请求一次,避免了多次调用的问题

2.6 白名单黑名单

三、防重放和防篡改拦截器

这里我们使用timestamp+nonce+sign对接口进行安全处理

1. 构建请求头

   @Data
   @Builder
   public class RequestHeader {
   /**

   • 签名
     /
     private String sign;
     /*
   • 时间戳
     /
     private Long timestamp;
     /*
   • 临时的数据
     */
     private String nonce;
     }

2. 保存请求流对象

   public class SignRequestWrapper extends HttpServletRequestWrapper {
   //用于将流保存下来
   private byte[] requestBody = null;
   public SignRequestWrapper(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 boolean isFinished() {
   return false;
   }
   @Override
   public boolean isReady() {
   return false;
   }
   @Override
   public void setReadListener(ReadListener readListener) {
   }
   @Override
   public int read() throws IOException {
   return bais.read();
   }
   };
   }
   @Override
   public BufferedReader getReader() throws IOException {
   return new BufferedReader(new InputStreamReader(getInputStream()));
   }
   }

3. 创建请求数据处理工具

   @Slf4j
   public class HttpDataUtil {
   /**

   • post请求处理：获取 Body 参数，转换为SortedMap
   • @param request
     /
     public static SortedMap<String, String> getBodyParams(final HttpServletRequest request) throws IOException {
     byte[] requestBody = StreamUtils.copyToByteArray(request.getInputStream());
     String body = new String(requestBody);
     return JsonUtils.parseObject(body, SortedMap.class);
     }
     /*
   • get请求处理：将URL请求参数转换成SortedMap
     */
     public static SortedMap<String, String> getUrlParams(HttpServletRequest request) {
     String param = "";
     SortedMap<String, String> result = new TreeMap<>();
     if (StringUtils.isEmpty(request.getQueryString())) {
     return result;
     }
     try {
     param = URLDecoder.decode(request.getQueryString(), "utf-8");
     } catch (UnsupportedEncodingException e) {
     e.printStackTrace();
     }
     String[] params = param.split("&");
     for (String s : params) {
     String[] array = s.split("=");
     result.put(array[0], array[1]);
     }
     return result;
     }
     }

4. 签名验证工具

   @Slf4j
   public class SignUtil {
   /**

   • 验证签名
   • 验证算法：把timestamp + JsonUtil.object2Json(SortedMap)合成字符串，然后MD5
     /
     @SneakyThrows
     public static boolean verifySign(SortedMap<String, String> map, RequestHeader requestHeader) {
     String params = requestHeader.getNonce() + requestHeader.getTimestamp() + JsonUtils.toJsonString(map);
     return verifySign(params, requestHeader);
     }
     /*
   • 验证签名
     */
     public static boolean verifySign(String params, RequestHeader requestHeader) {
     log.debug("客户端签名: {}", requestHeader.getSign());
     if (StringUtils.isEmpty(params)) {
     return false;
     }
     log.info("客户端上传内容: {}", params);
     String paramsSign = DigestUtils.md5DigestAsHex(params.getBytes()).toUpperCase();
     log.info("客户端上传内容加密后的签名结果: {}", paramsSign);
     return requestHeader.getSign().equals(paramsSign);
     }
     }

5. 创建拦截器SignFilter

   @Slf4j
   public class SignFilter implements Filter {
   private static final Long signMaxTime = 60L;
   private static final String NONCE_KEY = "x-nonce-";
   @Override
   public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
   HttpServletRequest httpRequest = (HttpServletRequest) servletRequest;
   log.info("过滤URL:{}", httpRequest.getRequestURI());
   //request数据流只能读取一次，这里保存request流
   HttpServletRequestWrapper requestWrapper = new SignRequestWrapper(httpRequest);
   //构建请求头
   String nonceHeader = httpRequest.getHeader("X-Nonce");
   String timeHeader = httpRequest.getHeader("X-Time");
   String signHeader = httpRequest.getHeader("X-Sign");
   //验证请求头是否存在
   if (StringUtils.isEmpty(nonceHeader) || ObjectUtils.isEmpty(timeHeader) || StringUtils.isEmpty(signHeader)) {
   throw new RuntimeException("请求头不存在");
   }
   RequestHeader requestHeader = RequestHeader.builder()
   .nonce(httpRequest.getHeader("X-Nonce"))
   .timestamp(Long.parseLong(httpRequest.getHeader("X-Time")))
   .sign(httpRequest.getHeader("X-Sign")).build();
   /*

   • 1.验证签名是否过期，防止重放
   • 判断timestamp时间戳与当前时间是否操过60s（过期时间根据业务情况设置）,如果超过了就提示签名过期。
     */
     long now = System.currentTimeMillis() / 1000;
     if (now - requestHeader.getTimestamp() > signMaxTime) {
     throw new RuntimeException("签名过期");
     }
     //2. 判断nonce，是否重复发送
     boolean nonceExists = RedisUtils.hasKey(NONCE_KEY + requestHeader.getNonce());
     if (nonceExists) {
     //请求重复
     throw new RuntimeException("请求重复");
     } else {
     RedisUtils.set(NONCE_KEY + requestHeader.getNonce(), requestHeader.getNonce(), signMaxTime);
     }
     // 3. 验证签名，防止篡改
     boolean accept;
     SortedMap<String, String> paramMap;
     switch (httpRequest.getMethod()) {
     case "GET":
     paramMap = HttpDataUtil.getUrlParams(requestWrapper);
     accept = SignUtil.verifySign(paramMap, requestHeader);
     break;
     case "POST":
     paramMap = HttpDataUtil.getBodyParams(requestWrapper);
     accept = SignUtil.verifySign(paramMap, requestHeader);
     break;
     default:
     accept = true;
     break;
     }
     if (accept) {
     filterChain.doFilter(requestWrapper, servletResponse);
     } else {
     throw new RuntimeException("签名有误，请重新请求");
     }
     }
     }

6. 配置拦截器

   @Configuration
   public class SignFilterConfiguration {
   @Bean
   public FilterRegistrationBean contextFilterRegistrationBean() {
   FilterRegistrationBean registration = new FilterRegistrationBean();
   registration.setFilter(new SignFilter());
   registration.addUrlPatterns("/sign/*");
   registration.setName("SignFilter");
   // 设置过滤器被调用的顺序
   registration.setOrder(1);
   return registration;
   }
   }

7. 测试

   @RequestMapping("")
   @RestController
   public class SignDemoController {
   @PostMapping("/sign/demo1")
   public R demo1(@RequestBody DemoDto demoDto) {
   System.out.println("===执行了demo1");
   return R.ok();
   }
   @GetMapping("/demo2")
   public R demo2() {
   System.out.println("执行了demo2====");
   return R.ok();
   }
   }
   @Data
   class DemoDto {
   private Integer age;
   private String username;
   private Long id;
   }