如何设计一个安全的对外接口？
对外接口安全措施的作用主要体现在两个方面，一方面是如何保证数据在传输过程中的安全性，另一方面是数据已经到达服务器端，服务器端如何识别数据。
1. 数据加密
数据在传输过程中是很容易被抓包的，如果直接传输，数据可以被任何人获取，所以必须对数据加密。加密方式有对称加密和非对称加密：
- 对称加密：对称密钥在加密和解密的过程中使用的密钥是相同的，常见的对称加密算法有 DES、AES。优点是计算速度快，缺点是在数据传送前，发送方和接收方必须商定好密钥，并完好保存。如果一方的密钥被泄露，那么加密信息也就不安全了；
- 非对称加密：服务端会生成一对密钥，私钥存放在服务器端，公钥可以发布给任何人使用。与对称加密相比，这种方式更安全，但速度慢太多了。
现在主流的做法是使用 HTTPS 协议，在 HTTP 和 TCP 之间添加一层加密层 (SSL 层)，这一层负责数据的加密和解密。HTTPS 的实现方式结合了对称加密与非对称加密的优点，在安全和性能方面都比较突出。
示例
javascript
const CryptoJS = require("crypto-js");
// 密钥，8 字节
const key = CryptoJS.enc.Utf8.parse('12345678');
// 偏移量，8 字节
const iv = CryptoJS.enc.Utf8.parse('12345678');// DES 加密
function encryptDES(data) {const encrypted = CryptoJS.DES.encrypt(data, key, {iv: iv,mode: CryptoJS.mode.CBC,padding: CryptoJS.pad.Pkcs7});return encrypted.toString();
}// DES 解密
function decryptDES(encryptedData) {const decrypted = CryptoJS.DES.decrypt(encryptedData, key, {iv: iv,mode: CryptoJS.mode.CBC,padding: CryptoJS.pad.Pkcs7});return decrypted.toString(CryptoJS.enc.Utf8);
}// 测试
const originalData = 'Hello, world!';
const encryptedData = encryptDES(originalData); //YcunRrQmVq9nAmF4fyALkw==
console.log('加密后的数据：', encryptedData);
const decryptedData = decryptDES(encryptedData);
console.log('解密后的数据：', decryptedData);
复制代码java
import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import org.apache.commons.codec.binary.Base64;
import org.springframework.stereotype.Component;public class DesUtil {// 密钥，长度为8个字符private static final String KEY = "12345678";// 偏移量，长度为8个字符private static final String IV = "12345678";// 加密算法private static final String ALGORITHM = "DES";// 加密模式private static final String TRANSFORMATION = "DES/CBC/PKCS5Padding";// 加密public static String encrypt(String input) throws Exception {// 创建密钥对象SecretKeySpec keySpec = new SecretKeySpec(KEY.getBytes(), ALGORITHM);// 创建偏移量对象IvParameterSpec ivSpec = new IvParameterSpec(IV.getBytes());// 创建加密器对象Cipher cipher = Cipher.getInstance(TRANSFORMATION);// 初始化加密器cipher.init(Cipher.ENCRYPT_MODE, keySpec, ivSpec);// 加密byte[] encrypted = cipher.doFinal(input.getBytes());// 将加密后的字节数组转换为Base64字符串return Base64.encodeBase64String(encrypted);}// 解密public static String decrypt(String input) throws Exception {// 创建密钥对象SecretKeySpec keySpec = new SecretKeySpec(KEY.getBytes(), ALGORITHM);// 创建偏移量对象IvParameterSpec ivSpec = new IvParameterSpec(IV.getBytes());// 创建解密器对象Cipher cipher = Cipher.getInstance(TRANSFORMATION);// 初始化解密器cipher.init(Cipher.DECRYPT_MODE, keySpec, ivSpec);// 将Base64字符串解码为字节数组byte[] decrypted = cipher.doFinal(Base64.decodeBase64(input));// 将解密后的字节数组转换为字符串return new String(decrypted);}// 测试public static void main(String[] args) throws Exception {String originalData = "Hello, world!";String encryptedData = encrypt(originalData);System.out.println(encryptedData); // YcunRrQmVq9nAmF4fyALkw==}
}
复制代码2. 数据加签
数据加签就是由发送者产生一段无法伪造的数字串，来保证数据在传输过程中不被篡改。数据如果已经通过 HTTPS 加密了，其加密部分只是在外网，而加签可以防止内网中数据被篡改。
数据签名使用较多的是 MD5 算法，将需要提交的数据通过某种方式组合，然后通过 MD5 生成一段加密字符串，这段加密字符串就是数据包的签名。而其中的用户密钥，客户端和服务端都保留一份，会更加安全。
示例
java
定义一个工具类来实现带密钥的MD5加签和验签：
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;public class MD5Util {public static String md5(String data, String key) {try {MessageDigest md = MessageDigest.getInstance("MD5");md.update((data + key).getBytes());byte[] digest = md.digest();StringBuilder sb = new StringBuilder();for (byte b : digest) {sb.append(String.format("%02x", b & 0xff));}return sb.toString();} catch (NoSuchAlgorithmException e) {throw new RuntimeException("MD5加签失败", e);}}public static boolean verify(String data, String sign, String key) {return md5(data, key).equals(sign);}
}复制代码在业务代码中使用该工具类进行MD5加签和验签：
@RestController
public class DemoController {private static final String KEY = "123456";@GetMapping("/demo")public String demo(String data, String sign) {// 对数据进行MD5加签String signData = MD5Util.md5(data, KEY);if (signData.equals(sign)) {// 验签通过return "验签通过";} else {// 验签不通过return "验签不通过";}}
}
复制代码javascript
定义一个工具类来实现带密钥的 MD5 加签和验签：
const CryptoJS = require("crypto-js");const MD5Util = {md5(data, key) {// 使用 crypto-js 库计算 MD5 值const hash = CryptoJS.MD5(data + key); return hash.toString();},verify(data, sign, key) {// 计算数据的签名const dataSign = this.md5(data, key); // 返回验签结果return dataSign === sign; }
};
复制代码在业务代码中使用该工具类进行 MD5 加签和验签：
const KEY = '123456';function demo(data, sign) {// 对数据进行 MD5 加签const signData = MD5Util.md5(data, KEY);if (signData === sign) {// 验签通过return '验签通过';} else {// 验签不通过return '验签不通过';}
}复制代码3. 时间戳机制
数据经过如上的加密、加签处理后，就算被抓包也不能看到真实的数据。但是有的不法者不关心真实数据，而是直接拿到抓取的数据包进行恶意请求。这时可以使用时间戳机制，在每次请求中加入当前的时间，服务器端会拿到当前时间与消息中的时间相减，看看是否在一个固定的时间范围内，比如 5 分钟，这样恶意请求的数据包是无法更改时间的，所以 5 分钟后就视为非法请求了。
java
定义一个拦截器：
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.concurrent.TimeUnit;public class TimeStampInterceptor implements HandlerInterceptor {@Overridepublic boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {// 获取请求头中的时间戳String timeStampStr = request.getHeader("timeStamp"); if (timeStampStr != null) {// 将时间戳转换为 long 类型long timeStamp = Long.parseLong(timeStampStr); // 获取当前时间戳long now = System.currentTimeMillis(); // 验证时间戳是否有效if (TimeUnit.MILLISECONDS.toMinutes(now - timeStamp) < 5) { return true;}}response.getWriter().print("时间戳无效！");response.getWriter().flush();response.getWriter().close();return false;}@Overridepublic void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {}@Overridepublic void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {}
}
复制代码将拦截器注册到springboot中：
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;@Configuration
public class WebConfig implements WebMvcConfigurer {@Overridepublic void addInterceptors(InterceptorRegistry registry) {// 添加需要拦截的接口路径registry.addInterceptor(new TimeStampInterceptor()).addPathPatterns("/api/**"); }
}
复制代码4. AppID 机制
大部分网站都需要用户名和密码才能登录，这其实也是一种安全机制。相应的对外接口也需要这么一种机制，使用接口的用户需要在后台开通 AppID，提供给用户相关的密钥。在调用的接口中需要提供 AppID+ 密钥，服务器端会进行相关的验证。生成唯一的 AppID 即可，根据实际情况看是否需要全局唯一，同时密钥使用字母、数字等特殊字符随机生成。
java
定义一个拦截器：
import org.apache.commons.codec.digest.DigestUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;public class AppIdSecretInterceptor implements HandlerInterceptor {@Value("${app.id}")private String appId;@Value("${app.secret}")private String appSecret;@Overridepublic boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {// 获取请求头中的 AppIDString appIdParam = request.getHeader("appId"); // 获取请求头中的密钥String secretParam = request.getHeader("secret"); // 验证 AppID 和密钥是否正确if (appId.equals(appIdParam) && DigestUtils.md5Hex(appIdParam + appSecret).equals(secretParam)) { return true;}response.getWriter().print("AppID 或密钥错误！");response.getWriter().flush();response.getWriter().close();return false;}@Overridepublic void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {}@Overridepublic void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {}
}复制代码将拦截器注册到springboot中：
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;@Configuration
public class WebConfig implements WebMvcConfigurer {@Overridepublic void addInterceptors(InterceptorRegistry registry) {// 添加需要拦截的接口路径registry.addInterceptor(new AppIdSecretInterceptor()).addPathPatterns("/api/**"); }
}
复制代码5. 限流机制
本来就是真实的用户，并且开通了 AppID，但出现了频繁调用接口的情况，这时需要给相关 AppID 限流处理，常用的限流算法包括：令牌桶限流、漏桶限流、计数器限流。
漏桶算法的原理是按照固定常量速率流出请求，流入请求速率任意，当请求数超过桶的容量时，新的请求等待或者拒绝服务，漏桶算法可以强制限制数据的传输速度。
令牌桶算法的原理是令牌桶算法 和漏桶算法 效果一样但方向相反的算法，更加容易理解。随着时间流逝，系统会按恒定 1/QPS 时间间隔（如果 QPS=100，则间隔是 10ms）往桶里加入 Token（想象和漏洞漏水相反，有个水龙头在不断的加水），如果桶已经满了就不再加了。新请求来临时，会各自拿走一个 Token，如果没有 Token 可拿了就阻塞或者拒绝服务。
计数器算法比较简单粗暴，主要用来限制总并发数，比如数据库连接池、线程池、秒杀的并发数。计数器限流只要一定时间内的总请求数超过设定的阀值，就会进行限流。
java
import com.google.common.util.concurrent.RateLimiter;
import org.springframework.web.servlet.HandlerInterceptor;import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;public class RateLimitInterceptor implements HandlerInterceptor {// 创建一个令牌桶，每秒放行 10 个请求private static final RateLimiter RATE_LIMITER = RateLimiter.create(10); @Overridepublic boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {// 尝试获取一个令牌if (RATE_LIMITER.tryAcquire()) { return true;}response.getWriter().print("请求过于频繁，请稍后重试！");response.getWriter().flush();response.getWriter().close();return false;}
}复制代码以上代码中，我们定义了一个拦截器 RateLimitInterceptor，并创建了一个 RATE_LIMITER 对象作为令牌桶，每秒放行 10 个请求。在 preHandle 方法中，我们使用 RATE_LIMITER.tryAcquire() 方法尝试获取一个令牌，如果获取成功，则返回 true，否则拒绝调用接口并返回 false。
拦截器注册到 Spring Boot：
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;@Configuration
public class WebConfig implements WebMvcConfigurer {@Overridepublic void addInterceptors(InterceptorRegistry registry) {// 添加需要拦截的接口路径registry.addInterceptor(new RateLimitInterceptor()).addPathPatterns("/api/**"); }
}
复制代码6. 黑名单机制
如果一个 AppID 进行过很多非法操作，或者专门有一个中黑系统，经过分析之后可以直接将此 AppID 列入黑名单，所有请求直接返回错误码。如何查看黑名单列表呢？可以给用户设置一个状态比如：初始化状态、正常状态、中黑状态、关闭状态等等。或者直接通过分布式配置中心，保存黑名单列表，每次检查用户是否在列表中即可。
java
创建一个黑名单服务，用于管理被禁用的 IP：
import org.springframework.stereotype.Service;import java.util.HashSet;
import java.util.Set;@Service
public class BlacklistService {// 存储被禁用的 IPprivate Set<String> blackList = new HashSet<>(); public void add(String ip) {blackList.add(ip);}public boolean contains(String ip) {return blackList.contains(ip);}
}
复制代码定义一个拦截器：
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;public class BlacklistInterceptor implements HandlerInterceptor {@Autowiredprivate BlacklistService blacklistService;@Overridepublic boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {String ip = request.getRemoteAddr();if (blacklistService.contains(ip)) {response.getWriter().print("您的 IP 已被禁用！");response.getWriter().flush();response.getWriter().close();return false;}return true;}
}
复制代码拦截器注册到 Spring Boot：
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;@Configuration
public class WebConfig implements WebMvcConfigurer {@Overridepublic void addInterceptors(InterceptorRegistry registry) {// 添加需要拦截的接口路径registry.addInterceptor(new BlacklistInterceptor()).addPathPatterns("/api/**"); }
}
复制代码7. 数据合法性校验
这是每个系统都会有的处理机制，只有在数据合法的情况下才会进行数据处理。每个系统都有自己的验证规则，当然也可能有一些常规性的规则，比如身份证号码长度和组成、电话号码长度和组成等等。
合法性校验包括常规性校验以及业务校验，前者包括签名校验、必填校验、长度校验、类型校验、格式校验等，后者根据实际业务而定，比如订单金额不能小于 0 等等。