【实战系列】OpenApi设计规范
为了统一、规范接口标准，为了业务能力的复用，为了接入方快速接入，所以必须要设计一套OpenApi的规范出来，又因为是统一的对外接口，所以需要额外的关注接口安全性、复用性等方面问题，接下来跟我一起来分析吧。...
·
文章目录
前言
为了统一、规范接口标准，为了业务能力的复用，为了接入方快速接入，所以必须要设计一套OpenApi的规范出来，又因为是统一的对外接口，所以需要额外的关注接口安全性、复用性等方面问题，接下来跟我一起来分析吧。
1. AppId、AppSecret
AppId的使用
因为AppId实际上就是一个标识，所以一般只要能保证系统内全局唯一即可，不过，为了能够防止有人拿着别人的AppId来请求，所以通常AppId都会配对一个AppSecret，可以理解为AppId的密码，最终的接口请求内容会根据AppId和AppSecret并按照一定的规则来生成一套签名，当请求方带着签名值去请求提供方时，提供方就会验证这个签名，只有验证通过才会继续处理。
AppId的生成
正如前面所说，AppId生成只要保证全局唯一即可，所以这里就不过多介绍了。
AppSecret生成
AppSecret的生成也很简单，只要与AppId能关联起来保证唯一即可。
2. sign签名
RSASignature
首先，在介绍签名方式之前，我们必须先了解2个概念，分别是：非对称加密算法（比如：RSA）、摘要算法（比如：MD5）。
简单来说：
非对称加密的应用场景一般有两种，一种是公钥加密，私钥解密，可以应用在加解密场景中（不过由于非对称加密的效率实在不高，用的比较少），还有一种就是结合摘要算法，把信息经过摘要后，再用私钥加密，公钥用来解密，可以应用在签名场景中，也是我们将要使用到的方式。
大致看看RSASignature签名的方式，稍后用到SHA256withRSA底层就是使用的这个方法。
摘要算法与非对称算法的最大区别就在于，它是一种不需要密钥的且不可逆的算法，也就是一旦明文数据经过摘要算法计算后，得到的密文数据一定是不可反推回来的。
二、签名的作用
好了，现在我们再来看看签名，签名主要可以用在两个场景，一种是数据防篡改，一种是身份防冒充，实际上刚好可以对应上前面我们介绍的两种算法。
1. 数据防篡改
顾名思义，就是防止数据在网络传输过程中被修改，摘要算法可以保证每次经过摘要算法的原始数据，计算出来的结果都一样，所以一般接口提供方只要用同样的原数据经过同样的摘要算法，然后与接口请求方生成的数据进行比较，如果一致则表示数据没有被篡改过。
2. 身份防冒充
这里身份防冒充，我们就要使用另一种方式，比如SHA256withRSA，其实现原理就是先用数据进行SHA256计算，然后再使用RSA私钥加密，对方解的时候也一样，先用RSA公钥解密，然后再进行SHA256计算，最后看结果是否匹配。
三、流程说明
前置准备
1、正如前面介绍，appId、appSecret当前通过线下的方式，双方约定好，appSecret需要接口请求方自行保密。
2、公私钥可以由接口提供方来生成，同样通过线下的方式，把私钥交给对方，并要求对方需保密。
交互流程
来自百度百科
接口请求方
1、接口请求方，首先把业务参数，进行摘要算法计算，生成一个签名（sign）
// 业务请求参数
UserEntity userEntity = new UserEntity();
userEntity.setUserId("1");
userEntity.setPhone("13912345678");
// 使用sha256的方式生成签名
String sign = getSHA256Str(JSONObject.toJSONString(userEntity));
sign=c630885277f9d31cf449697238bfc6b044a78545894c83aad2ff6d0b7d486bc5
2、然后继续拼接header部的参数，可以使用&符合连接，使用set集合完成自然排序，并且过滤参数为空的key，最后使用私钥加签的方式，得到appSign
Map<String, String> data = Maps.newHashMap();
data.put("appId", appId);
data.put("nonce", nonce);
data.put("sign", sign);
data.put("timestamp", timestamp);
Set<String> keySet = data.keySet();
String[] keyArray = keySet.toArray(new String[keySet.size()]);
Arrays.sort(keyArray);
StringBuilder sb = new StringBuilder();
for (String k : keyArray) {
if (data.get(k).trim().length() > 0) // 参数值为空，则不参与签名
sb.append(k).append("=").append(data.get(k).trim()).append("&");
}
sb.append("appSecret=").append(appSecret);
System.out.println("【请求方】拼接后的参数：" + sb.toString());
System.out.println();
【请求方】拼接后的参数：appId=123456&nonce=1234&sign=c630885277f9d31cf449697238bfc6b044a78545894c83aad2ff6d0b7d486bc5×tamp=1653057661381&appSecret=654321
【请求方】appSign：m/xk0fkDZlHEkbYSpCPdpbriG/EWG9gNZtInoYOu2RtrLMzHNM0iZe1iL4p/+IedAJN2jgG9pS5o5NZH1i55TVoTbZePdCbR9CEJoHq2TZLIiKPeoRgDimAl14V5jHZiMQCXS8RxWT63W8MKFyZQtB7xCtxVD7+IvLGQOAWn7QX+EmfAUvhgjkaVf2YLk9J9LqtyjfTYeloiP901ZsBZo5y9Gs5P73b+JoEcxmGZRv+Fkv3HnHWTQEpl7W6Lrmd0j44/XupwzHxaanRo5k0ALOVSFohdyMtHk3eOYx/bj+GeMKf8PN4J4tsPndnjyu4XUOnh74aaW9oC2DLiIzr4+Q==
3、最后把参数组装，发送给接口提供方
Header header = Header.builder()
.appId(appId)
.nonce(nonce)
.sign(sign)
.timestamp(timestamp)
.appSign(appSign)
.build();
APIRequestEntity apiRequestEntity = new APIRequestEntity();
apiRequestEntity.setHeader(header);
apiRequestEntity.setBody(userEntity);
String requestParam = JSONObject.toJSONString(apiRequestEntity);
System.out.println("【请求方】接口请求参数: " + requestParam);
【请求方】接口请求参数: {"body":{"phone":"13912345678","userId":"1"},"header":{"appId":"123456","appSign":"m/xk0fkDZlHEkbYSpCPdpbriG/EWG9gNZtInoYOu2RtrLMzHNM0iZe1iL4p/+IedAJN2jgG9pS5o5NZH1i55TVoTbZePdCbR9CEJoHq2TZLIiKPeoRgDimAl14V5jHZiMQCXS8RxWT63W8MKFyZQtB7xCtxVD7+IvLGQOAWn7QX+EmfAUvhgjkaVf2YLk9J9LqtyjfTYeloiP901ZsBZo5y9Gs5P73b+JoEcxmGZRv+Fkv3HnHWTQEpl7W6Lrmd0j44/XupwzHxaanRo5k0ALOVSFohdyMtHk3eOYx/bj+GeMKf8PN4J4tsPndnjyu4XUOnh74aaW9oC2DLiIzr4+Q==","nonce":"1234","sign":"c630885277f9d31cf449697238bfc6b044a78545894c83aad2ff6d0b7d486bc5","timestamp":"1653057661381"}}
接口提供方
1、从请求参数中，先获取body的内容，然后签名，完成对参数校验
Header header = apiRequestEntity.getHeader();
UserEntity userEntity = JSONObject.parseObject(JSONObject.toJSONString(apiRequestEntity.getBody()), UserEntity.class);
// 首先，拿到参数后同样进行签名
String sign = getSHA256Str(JSONObject.toJSONString(userEntity));
if (!sign.equals(header.getSign())) {
throw new Exception("数据签名错误！");
}
2、从header中获取相关信息，并使用公钥进行验签，完成身份认证
// 从header中获取相关信息，其中appSecret需要自己根据传过来的appId来获取
String appId = header.getAppId();
String appSecret = getAppSecret(appId);
String nonce = header.getNonce();
String timestamp = header.getTimestamp();
// 按照同样的方式生成appSign，然后使用公钥进行验签
Map<String, String> data = Maps.newHashMap();
data.put("appId", appId);
data.put("nonce", nonce);
data.put("sign", sign);
data.put("timestamp", timestamp);
Set<String> keySet = data.keySet();
String[] keyArray = keySet.toArray(new String[keySet.size()]);
Arrays.sort(keyArray);
StringBuilder sb = new StringBuilder();
for (String k : keyArray) {
if (data.get(k).trim().length() > 0) // 参数值为空，则不参与签名
sb.append(k).append("=").append(data.get(k).trim()).append("&");
}
sb.append("appSecret=").append(appSecret);
if (!rsaVerifySignature(sb.toString(), appKeyPair.get(appId).get("publicKey"), header.getAppSign())) {
throw new Exception("公钥验签错误！");
}
System.out.println();
System.out.println("【提供方】验证通过！");
完整代码补充
package openApi;
import com.alibaba.fastjson.JSONObject;
import com.google.common.collect.Maps;
import lombok.SneakyThrows;
import org.apache.commons.codec.binary.Hex;
import java.nio.charset.StandardCharsets;
import java.security.*;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.*;
public class AppUtils {
/**
* key:appId、value:appSecret
*/
static Map<String, String> appMap = Maps.newConcurrentMap();
/**
* 分别保存生成的公私钥对
* key:appId，value:公私钥对
*/
static Map<String, Map<String, String>> appKeyPair = Maps.newConcurrentMap();
public static void main(String[] args) throws Exception {
// 模拟生成appId、appSecret
String appId = initAppInfo();
// 根据appId生成公私钥对
initKeyPair(appId);
// 模拟请求方
String requestParam = clientCall();
// 模拟提供方验证
serverVerify(requestParam);
}
private static String initAppInfo() {
// appId、appSecret生成规则，依据之前介绍过的方式，保证全局唯一即可
String appId = "123456";
String appSecret = "654321";
appMap.put(appId, appSecret);
return appId;
}
private static void serverVerify(String requestParam) throws Exception {
APIRequestEntity apiRequestEntity = JSONObject.parseObject(requestParam, APIRequestEntity.class);
Header header = apiRequestEntity.getHeader();
UserEntity userEntity = JSONObject.parseObject(JSONObject.toJSONString(apiRequestEntity.getBody()), UserEntity.class);
// 首先，拿到参数后同样进行签名
String sign = getSHA256Str(JSONObject.toJSONString(userEntity));
if (!sign.equals(header.getSign())) {
throw new Exception("数据签名错误！");
}
// 从header中获取相关信息，其中appSecret需要自己根据传过来的appId来获取
String appId = header.getAppId();
String appSecret = getAppSecret(appId);
String nonce = header.getNonce();
String timestamp = header.getTimestamp();
// 按照同样的方式生成appSign，然后使用公钥进行验签
Map<String, String> data = Maps.newHashMap();
data.put("appId", appId);
data.put("nonce", nonce);
data.put("sign", sign);
data.put("timestamp", timestamp);
Set<String> keySet = data.keySet();
String[] keyArray = keySet.toArray(new String[keySet.size()]);
Arrays.sort(keyArray);
StringBuilder sb = new StringBuilder();
for (String k : keyArray) {
if (data.get(k).trim().length() > 0) // 参数值为空，则不参与签名
sb.append(k).append("=").append(data.get(k).trim()).append("&");
}
sb.append("appSecret=").append(appSecret);
if (!rsaVerifySignature(sb.toString(), appKeyPair.get(appId).get("publicKey"), header.getAppSign())) {
throw new Exception("公钥验签错误！");
}
System.out.println();
System.out.println("【提供方】验证通过！");
}
public static String clientCall() {
// 假设接口请求方与接口提供方，已经通过其他渠道，确认了双方交互的appId、appSecret
String appId = "123456";
String appSecret = "654321";
String timestamp = String.valueOf(System.currentTimeMillis());
// 应该为随机数，演示随便写一个
String nonce = "1234";
// 业务请求参数
UserEntity userEntity = new UserEntity();
userEntity.setUserId("1");
userEntity.setPhone("13912345678");
// 使用sha256的方式生成签名
String sign = getSHA256Str(JSONObject.toJSONString(userEntity));
Map<String, String> data = Maps.newHashMap();
data.put("appId", appId);
data.put("nonce", nonce);
data.put("sign", sign);
data.put("timestamp", timestamp);
Set<String> keySet = data.keySet();
String[] keyArray = keySet.toArray(new String[keySet.size()]);
Arrays.sort(keyArray);
StringBuilder sb = new StringBuilder();
for (String k : keyArray) {
if (data.get(k).trim().length() > 0) // 参数值为空，则不参与签名
sb.append(k).append("=").append(data.get(k).trim()).append("&");
}
sb.append("appSecret=").append(appSecret);
System.out.println("【请求方】拼接后的参数：" + sb.toString());
System.out.println();
// 使用sha256withRSA的方式对header中的内容加签
String appSign = sha256withRSASignature(appKeyPair.get(appId).get("privateKey"), sb.toString());
System.out.println("【请求方】appSign：" + appSign);
System.out.println();
// 请求参数组装
Header header = Header.builder()
.appId(appId)
.nonce(nonce)
.sign(sign)
.timestamp(timestamp)
.appSign(appSign)
.build();
APIRequestEntity apiRequestEntity = new APIRequestEntity();
apiRequestEntity.setHeader(header);
apiRequestEntity.setBody(userEntity);
String requestParam = JSONObject.toJSONString(apiRequestEntity);
System.out.println("【请求方】接口请求参数: " + requestParam);
return requestParam;
}
/**
* 私钥签名
*
* @param privateKeyStr
* @param dataStr
* @return
*/
public static String sha256withRSASignature(String privateKeyStr, String dataStr) {
try {
byte[] key = Base64.getDecoder().decode(privateKeyStr);
byte[] data = dataStr.getBytes();
PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(key);
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
Signature signature = Signature.getInstance("SHA256withRSA");
signature.initSign(privateKey);
signature.update(data);
return new String(Base64.getEncoder().encode(signature.sign()));
} catch (Exception e) {
throw new RuntimeException("签名计算出现异常", e);
}
}
/**
* 公钥验签
*
* @param dataStr
* @param publicKeyStr
* @param signStr
* @return
* @throws Exception
*/
public static boolean rsaVerifySignature(String dataStr, String publicKeyStr, String signStr) throws Exception {
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(Base64.getDecoder().decode(publicKeyStr));
PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec);
Signature signature = Signature.getInstance("SHA256withRSA");
signature.initVerify(publicKey);
signature.update(dataStr.getBytes());
return signature.verify(Base64.getDecoder().decode(signStr));
}
/**
* 生成公私钥对
*
* @throws Exception
*/
public static void initKeyPair(String appId) throws Exception {
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
keyPairGenerator.initialize(2048);
KeyPair keyPair = keyPairGenerator.generateKeyPair();
RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
Map<String, String> keyMap = Maps.newHashMap();
keyMap.put("publicKey", new String(Base64.getEncoder().encode(publicKey.getEncoded())));
keyMap.put("privateKey", new String(Base64.getEncoder().encode(privateKey.getEncoded())));
appKeyPair.put(appId, keyMap);
}
private static String getAppSecret(String appId) {
return String.valueOf(appMap.get(appId));
}
@SneakyThrows
public static String getSHA256Str(String str) {
MessageDigest messageDigest;
messageDigest = MessageDigest.getInstance("SHA-256");
byte[] hash = messageDigest.digest(str.getBytes(StandardCharsets.UTF_8));
return Hex.encodeHexString(hash);
}
}
3. 其他的一些保护措施
timestamp
前面在接口设计中，我们使用到了timestamp，这个参数主要可以用来防止同一个请求参数被无限期的使用。
稍微修改一下原服务端校验逻辑，增加了5分钟有效期的校验逻辑。
private static void serverVerify(String requestParam) throws Exception {
APIRequestEntity apiRequestEntity = JSONObject.parseObject(requestParam, APIRequestEntity.class);
Header header = apiRequestEntity.getHeader();
UserEntity userEntity = JSONObject.parseObject(JSONObject.toJSONString(apiRequestEntity.getBody()), UserEntity.class);
// 首先，拿到参数后同样进行签名
String sign = getSHA256Str(JSONObject.toJSONString(userEntity));
if (!sign.equals(header.getSign())) {
throw new Exception("数据签名错误！");
}
// 从header中获取相关信息，其中appSecret需要自己根据传过来的appId来获取
String appId = header.getAppId();
String appSecret = getAppSecret(appId);
String nonce = header.getNonce();
String timestamp = header.getTimestamp();
// 请求时间有效期校验
long now = LocalDateTime.now().atZone(ZoneId.systemDefault()).toInstant().toEpochMilli();
if ((now - Long.parseLong(timestamp)) / 1000 / 60 >= 5) {
throw new Exception("请求过期！");
}
cache.put(appId + "_" + nonce, "1");
// 按照同样的方式生成appSign，然后使用公钥进行验签
Map<String, String> data = Maps.newHashMap();
data.put("appId", appId);
data.put("nonce", nonce);
data.put("sign", sign);
data.put("timestamp", timestamp);
Set<String> keySet = data.keySet();
String[] keyArray = keySet.toArray(new String[0]);
Arrays.sort(keyArray);
StringBuilder sb = new StringBuilder();
for (String k : keyArray) {
if (data.get(k).trim().length() > 0) // 参数值为空，则不参与签名
sb.append(k).append("=").append(data.get(k).trim()).append("&");
}
sb.append("appSecret=").append(appSecret);
if (!rsaVerifySignature(sb.toString(), appKeyPair.get(appId).get("publicKey"), header.getAppSign())) {
throw new Exception("验签错误！");
}
System.out.println();
System.out.println("【提供方】验证通过！");
}
nonce
nonce值是一个由接口请求方生成的随机数，在有需要的场景中，可以用它来实现请求一次性有效，也就是说同样的请求参数只能使用一次，这样可以避免接口重放攻击。
具体实现方式：接口请求方每次请求都会随机生成一个不重复的nonce值，接口提供方可以使用一个存储容器（为了方便演示，我使用的是guava提供的本地缓存，生产环境中可以使用redis这样的分布式存储方式），每次先在容器中看看是否存在接口请求方发来的nonce值，如果不存在则表明是第一次请求，则放行，并且把当前nonce值保存到容器中，这样，如果下次再使用同样的nonce来请求则容器中一定存在，那么就可以判定是无效请求了。
这里可以设置缓存的失效时间为5分钟，因为前面有效期已经做了5分钟的控制。
static Cache<String, String> cache = CacheBuilder.newBuilder()
.expireAfterWrite(5, TimeUnit.MINUTES)
.build();
private static void serverVerify(String requestParam) throws Exception {
APIRequestEntity apiRequestEntity = JSONObject.parseObject(requestParam, APIRequestEntity.class);
Header header = apiRequestEntity.getHeader();
UserEntity userEntity = JSONObject.parseObject(JSONObject.toJSONString(apiRequestEntity.getBody()), UserEntity.class);
// 首先，拿到参数后同样进行签名
String sign = getSHA256Str(JSONObject.toJSONString(userEntity));
if (!sign.equals(header.getSign())) {
throw new Exception("数据签名错误！");
}
// 从header中获取相关信息，其中appSecret需要自己根据传过来的appId来获取
String appId = header.getAppId();
String appSecret = getAppSecret(appId);
String nonce = header.getNonce();
String timestamp = header.getTimestamp();
// 请求时间有效期校验
long now = LocalDateTime.now().atZone(ZoneId.systemDefault()).toInstant().toEpochMilli();
if ((now - Long.parseLong(timestamp)) / 1000 / 60 >= 5) {
throw new Exception("请求过期！");
}
// nonce有效性判断
String str = cache.getIfPresent(appId + "_" + nonce);
if (Objects.nonNull(str)) {
throw new Exception("请求失效！");
}
cache.put(appId + "_" + nonce, "1");
// 按照同样的方式生成appSign，然后使用公钥进行验签
Map<String, String> data = Maps.newHashMap();
data.put("appId", appId);
data.put("nonce", nonce);
data.put("sign", sign);
data.put("timestamp", timestamp);
Set<String> keySet = data.keySet();
String[] keyArray = keySet.toArray(new String[0]);
Arrays.sort(keyArray);
StringBuilder sb = new StringBuilder();
for (String k : keyArray) {
if (data.get(k).trim().length() > 0) // 参数值为空，则不参与签名
sb.append(k).append("=").append(data.get(k).trim()).append("&");
}
sb.append("appSecret=").append(appSecret);
if (!rsaVerifySignature(sb.toString(), appKeyPair.get(appId).get("publicKey"), header.getAppSign())) {
throw new Exception("验签错误！");
}
System.out.println();
System.out.println("【提供方】验证通过！");
}
白名单机制
使用白名单机制可以进一步加强接口的安全性，一旦服务与服务交互可以使用，接口提供方可以限制只有白名单内的IP才能访问，这样接口请求方只要把其出口IP提供出来即可。
黑名单机制
与之对应的黑名单机制，则是应用在服务端与客户端的交互，由于客户端IP都是不固定的，所以无法使用白名单机制，不过我们依然可以使用黑名单拦截一些已经被识别为非法请求的IP。
限流、熔断、降级
最后限流、熔断、降级这些应该都是接口设计的标准规范，所以开放接口在设计时就更应该要考虑清楚，尤其是限流，接口提供方在对外提供时就应该与请求方约定清楚。
其他合法性校验
最后，哪些字段必填，哪些字段非必填，字段类型、长度、格式，基本业务校验也都应该确认清楚。
权威｜前沿｜技术｜干货｜国内首个API全生命周期开发者社区
更多推荐
4
0- 0
已为社区贡献1条内容
所有评论(0)