如何为开放平台设计一个安全好用的OpenApi-每日运维

前言

为了确保软件接口的标准化和规范化，实现业务模块的重用性和灵活性，并提高接口的易用性和安全性，OpenAPI规范应运而生。这一规范通过制定统一的接口协议，规定了接口的格式、参数、响应和使用方法等内容，从而提高了接口的可维护性和可扩展性。同时，为了也需要考虑接口的安全性和稳定性，本文将针对这些方面介绍一些具体的实践方式。

一、AppId和AppSecret

AppId的使用

AppId作为一种全局唯一的标识符，其作用主要在于方便用户身份识别以及数据分析等方面。为了防止其他用户通过恶意使用别人的AppId来发起请求，一般都会采用配对AppSecret的方式，类似于一种密码。AppId和AppSecret通常会组合生成一套签名，并按照一定规则进行加密处理。在请求方发起请求时，需要将这个签名值一并提交给提供方进行验证。如果签名验证通过，则可以进行数据交互，否则将被拒绝。这种机制能够保证数据的安全性和准确性，提高系统的可靠性和可用性。

AppId的生成

正如前面所说，AppId就是有一个身份标识，生成时只要保证全局唯一即可。

AppSecret生成

AppSecret就是密码，按照一般的的密码安全性要求生成即可。

二、sign签名

RSASignature

首先，在介绍签名方式之前，我们必须先了解2个概念，分别是：非对称加密算法（比如：RSA）、摘要算法（比如：MD5）。

简单来说，非对称加密的应用场景一般有两种，一种是公钥加密，私钥解密，可以应用在加解密场景中（不过由于非对称加密的效率实在不高，用的比较少），还有一种就是结合摘要算法，把信息经过摘要后，再用私钥加密，公钥用来解密，可以应用在签名场景中，也是我们将要使用到的方式。

大致看看RSASignature签名的方式，稍后用到SHA256withRSA底层就是使用的这个方法。

在这里插入图片描述

摘要算法与非对称算法的最大区别就在于，它是一种不需要密钥的且不可逆的算法，也就是一旦明文数据经过摘要算法计算后，得到的密文数据一定是不可反推回来的。

签名的作用

好了，现在我们再来看看签名，签名主要可以用在两个场景，一种是数据防篡改，一种是身份防冒充，实际上刚好可以对应上前面我们介绍的两种算法。

数据防篡改

顾名思义，就是防止数据在网络传输过程中被修改，摘要算法可以保证每次经过摘要算法的原始数据，计算出来的结果都一样，所以一般接口提供方只要用同样的原数据经过同样的摘要算法，然后与接口请求方生成的数据进行比较，如果一致则表示数据没有被篡改过。

身份防冒充

这里身份防冒充，我们就要使用另一种方式，比如SHA256withRSA，其实现原理就是先用数据进行SHA256计算，然后再使用RSA私钥加密，对方解的时候也一样，先用RSA公钥解密，然后再进行SHA256计算，最后看结果是否匹配。

三、使用示例

前置准备

在没有自动化开放平台时，appId、appSecret可直接通过线下的方式给到接入方，appSecret需要接入方自行保存好，避免泄露。也可以自行

公私钥可以由接口提供方来生成，同样通过线下的方式，把私钥交给对方，并要求对方需保密。

交互流程

在这里插入图片描述

客户端准备

接口请求方，首先把业务参数，进行摘要算法计算，生成一个签名（sign）

// 业务请求参数
UserEntity userEntity = new UserEntity();
userEntity.setUserId("1");
userEntity.setPhone("13912345678");

// 使用sha256的方式生成签名
String sign = getSHA256Str(JSONObject.toJSONString(userEntity));

sign=c630885277f9d31cf449697238bfc6b044a78545894c83aad2ff6d0b7d486bc5

然后继续拼接header部的参数，可以使用&符合连接，使用Set集合完成自然排序，并且过滤参数为空的key，最后使用私钥加签的方式，得到appSign。

Map data = Maps.newHashMap();
data.put("appId", appId);
data.put("nonce", nonce);
data.put("sign", sign);
data.put("timestamp", timestamp);
Set 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==

最后把参数组装，发送给接口提供方。

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"}}

在这里插入图片描述

服务端准备

从请求参数中，先获取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("数据签名错误！");
}

从header中获取相关信息，并使用公钥进行验签，完成身份认证

// 从header中获取相关信息，其中appSecret需要自己根据传过来的appId来获取
String appId = header.getAppId();
String appSecret = getAppSecret(appId);
String nonce = header.getNonce();
String timestamp = header.getTimestamp();
// 按照同样的方式生成appSign，然后使用公钥进行验签
Map data = Maps.newHashMap();
data.put("appId", appId);
data.put("nonce", nonce);
data.put("sign", sign);
data.put("timestamp", timestamp);
Set 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 appMap = Maps.newConcurrentMap();

    /**
     * 分别保存生成的公私钥对
     * key:appId，value:公私钥对
     */
    static Map 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 data = Maps.newHashMap();
        data.put("appId", appId);
        data.put("nonce", nonce);
        data.put("sign", sign);
        data.put("timestamp", timestamp);
        Set 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 data = Maps.newHashMap();
        data.put("appId", appId);
        data.put("nonce", nonce);
        data.put("sign", sign);
        data.put("timestamp", timestamp);
        Set 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 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);
    }

}

四、常见防护手段

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 data = Maps.newHashMap();
    data.put("appId", appId);
    data.put("nonce", nonce);
    data.put("sign", sign);
    data.put("timestamp", timestamp);
    Set 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 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 data = Maps.newHashMap();
    data.put("appId", appId);
    data.put("nonce", nonce);
    data.put("sign", sign);
    data.put("timestamp", timestamp);
    Set 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("【提供方】验证通过！");
}

访问权限

数据访问权限，一般可根据appId的身份来获取开放给其的相应权限，要确保每个appId只能访问其权限范围内的数据。

参数合法性校验

参数的合法性校验应该是每个接口必备的，无论是前端发起的请求，还是后端的其他调用都必须对参数做校验，比如：参数的长度、类型、格式，必传参数是否有传，是否符合约定的业务规则等等。

推荐使用SpringBoot Validation来快速实现一些基本的参数校验。

参考如下示例：

@Data
@ToString
public class DemoEntity {
	
	// 不能为空，比较时会除去空格
    @NotBlank(message = "名称不能为空")
    private String name;
	
	// amount必须是一个大于等于5，小于等于10的数字
    @DecimalMax(value = "10")
    @DecimalMin(value = "5")
    private BigDecimal amount;

	// 必须符合email格式
    @Email
    private String email;
	
	// size长度必须在5到10之间
    @Size(max = 10, min = 5)
    private String size;
	
	// age大小必须在18到35之间
    @Min(value = 18)
    @Max(value = 35)
    private int age;
	
	// user不能为null
    @NotNull
    private User user;
	
	// 限制必须为小数，且整数位integer最多2位，小数位fraction最多为4位
    @Digits(integer = 2, fraction = 4)
    private BigDecimal digits;
	
	// 限制必须为未来的日期
    @Future
    private Date future;

	// 限制必须为过期的日期
    @Past
    private Date past;
	
	// 限制必须是一个未来或现在的时间
    @FutureOrPresent
    private Date futureOrPast;
	
	// 支持正则表达式
	@Pattern(regexp = "^\d+$")
	private String digit;
}

@RestController
@Slf4j
@RequestMapping("/valid")
public class TestValidController {

    @RequestMapping("/demo1")
    public String demo12(@Validated @RequestBody DemoEntity demoEntity) {
        try {
            return "SUCCESS";
        } catch (Exception e) {
            log.error(e.getMessage(), e);
            return "FAIL";
        }
    }
}

限流保护

在设计接口时，我们应当对接口的负载能力做出评估，尤其是开放给外部使用时，这样当实际请求流量超过预期流量时，我们便可采取相应的预防策略，以免服务器崩溃。

一般来说限流主要是为了防止恶意刷站请求，爬虫等非正常的业务访问，因此一般来说采取的方式都是直接丢弃超出阈值的部分。

限流的具体实现有多种，单机版可以使用Guava的RateLimiter，分布式可以使用Redis，想要更加完善的成套解决方案则可以使用阿里开源的Sentinel。

敏感数据访问

敏感信息一般包含，身份证、手机号、银行卡号、车牌号、姓名等等，应该按照脱敏规则进行处理。

白名单机制

使用白名单机制可以进一步加强接口的安全性，一旦服务与服务交互可以使用，接口提供方可以限制只有白名单内的IP才能访问，这样接口请求方只要把其出口IP提供出来即可。

黑名单机制

与之对应的黑名单机制，则是应用在服务端与客户端的交互，由于客户端IP都是不固定的，所以无法使用白名单机制，不过我们依然可以使用黑名单拦截一些已经被识别为非法请求的IP。

五、其他考虑

名称和描述：API 的名称和描述应该简洁明了，并清晰地表明其功能和用途。

请求和响应：API 应该支持标准的 HTTP 请求方法，如 GET、POST、PUT 和 DELETE，并定义这些方法的参数和响应格式。

错误处理：API 应该定义各种错误码，并提供有关错误的详细信息。

文档和示例：API 应该提供文档和示例，以帮助开发人员了解如何使用该 API，并提供示例数据以进行测试。

可扩展：API应当考虑未来的升级扩展不但能够向下兼容（一般可以在接口参数中添加接口的版本号），还能方便添加新的能力。

如何为开放平台设计一个安全好用的OpenApi

一、AppId和AppSecret

AppId的使用

AppId的生成

AppSecret生成

二、sign签名

数据防篡改

身份防冒充

三、使用示例

客户端准备

服务端准备

完整代码示例

四、常见防护手段

timestamp

nonce

访问权限

参数合法性校验

限流保护

敏感数据访问

白名单机制

黑名单机制

五、其他考虑

相关文章

发布评论取消回复

醒在深海的猫

oracle 自动撤销

【OceanBase DBA早下班系列】—— obdiag 收集的OB火焰图/扁鹊图解读

Vanilla OS 2 “Orchid” 正式发布，“不可变” Linux 发行版

如何为开放平台设计一个安全好用的OpenApi

一、AppId和AppSecret

AppId的使用

AppId的生成

AppSecret生成

二、sign签名

数据防篡改

身份防冒充

三、使用示例

客户端准备

服务端准备

完整代码示例

四、常见防护手段

timestamp

nonce

访问权限

参数合法性校验

限流保护

敏感数据访问

白名单机制

黑名单机制

五、其他考虑

相关文章

发布评论 取消回复

发布评论取消回复