当前位置:网站首页>【实战系列】OpenApi设计规范

【实战系列】OpenApi设计规范

2022-08-11 07:39:00 码拉松

前言

为了统一、规范接口标准,为了业务能力的复用,为了接入方快速接入,所以必须要设计一套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&timestamp=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。

限流、熔断、降级

最后限流、熔断、降级这些应该都是接口设计的标准规范,所以开放接口在设计时就更应该要考虑清楚,尤其是限流,接口提供方在对外提供时就应该与请求方约定清楚。

其他合法性校验

最后,哪些字段必填,哪些字段非必填,字段类型、长度、格式,基本业务校验也都应该确认清楚。

原网站

版权声明
本文为[码拉松]所创,转载请带上原文链接,感谢
https://blog.csdn.net/CSDN_WYL2016/article/details/126217804