【Cfeng Work】 Open API的intro和梳理

OpenAPI 开放平台

内容管理

- Open API intro
- 腾讯云OpenAPI
- - OpenAPI请求
  - API密钥管理
  - 云API签名过程
  - - 拼接规范请求串 CanonicalRequest
    - 拼接待签名字符串
    - 计算签名
    - 拼接到Authorization中
  - 云API签名失败规范
  - Token 和长期密钥
  - 公共参数
- OpenApi设计
- - AppId、AppSecret
  - sign签名
  - timestamp 时间戳保证有效期
  - nonce保证一次性，避免重放
  - 黑白名单
  - 限流、熔断、降级
  - 合法性校验（参数）

对于OpenAPI开放平台的intro和理解

之前对于OpenAPI的理解只是局限在调用Google的相关接口返回数据… 实际上OpenAPI的设计需要思考很多

Cfeng 最近接触到OpenAPI的内容，需要规范化设计OpenAPI，like 抖音开放平台、腾讯云的OpenAPI，这里分享一下自我见解

Open API intro

Open API 就是开放API，OpenAPI是服务型web项目的一种应用，网站（应用）服务商将自己网站的服务封装为一系列API 开放Open出去，供第三方开发者使用， OpenAPI 也就是开放网站部分服务API

提供OpenAPI的平台（网站等）就是开放平台

开放平台：第一种为技术型开放，比如baidu等将需求开放给第三方开发者，第二种是软件系统（应用）公开 API或者函数function，使外部程序可以使用软件系统的资源，增加功能，而不需要更改该软件系统的代码

简单理解，就是当前软件系统公开的API接口，第三方的开放者可以调用该接口获取当前软件系统的资源

这里就涉及到了鉴权、认证等具体操作流程

腾讯云OpenAPI

Cfeng注册了各个开放平台的账户，查看OpenAPI的设计，这里就以腾讯云为例，各个平台的设计思路都是差不多的

OpenAPI请求

请求调用：服务地址，通信协议，请求方法，字符编码

调用腾讯云服务的OpenAPI需要提供服务地址，也就是开放OpenAPI的服务器地址，eg ：cvm.tencentcloudapi.com；

通信协议当然采用安全的HTTPS，高安全性

请求方法：比如GET和POST【application/json; …】

字符编码：采用UTF-8

API密钥管理

使用API密钥签名API请求，腾讯云收到请求，比对签名串，验证通过才会给与资源【腾讯云控制台SecretKey无法直接查看，只能发送短信短暂查看】，密钥就和token一样，如果泄露别人会获得相同的权限造成损失；

给出的密钥保护方式：将密钥隐藏在环境变量中，存放在安全位置…

当需要发起请求时，通过变量方式调用，塞入请求头进行签名…

import os

from tencentcloud.common import credential
from tencentcloud.cvm.v20170312 import cvm_client, models

try:
    cred = credential.Credential(
        os.environ.get("TENCENTCLOUD_SECRET_ID"),
        os.environ.get("TENCENTCLOUD_SECRET_KEY"))
    client = cvm_client.CvmClient(cred, "ap-guangzhou")
    req = models.DescribeInstancesRequest()
    resp = client.DescribeInstances(req)
    print(resp)
except Exception as err:
    print(err)
    
# 像这里使用python， 这里也是包装过的了，像cred和client直接就会塞入请求头， req指定一个Action， 就可以发起请求获取资源

按照解释，API密钥代表的就是账号身份以及所拥有的权限，使用API 就可以直接操作用户名下的所有的资源【普通用户可能是图形界面的方式，开放者就可以直接调用API获取自己拥有的资源进行操作】

密钥可以直接生成，包含SecretId和SecretKey， 密钥是构建API的重要凭证，用于调用时生成签名 【密钥可以手动禁用，并且可以在控制台查看密钥最近使用的时间决定禁用与否】

腾讯云的API会对每一个调用请求进行身份验证，用户需要使用安全凭证，经过特定的步骤对请求进行签名Signature，需要在请求的公共参数中指定签名结果并以指定的方式发送 request

签名Signature的目的就是验证请求者的身份（确保request是持有密钥的人发送的，防止劫持），以及保护传输数据，【加密】，发送方使用签名算法生成一个Hash值连同请求一起发送，服务器收到后以同样的过程计算，并验证hash值，如果被篡改，那么API拒绝此请求

腾讯云中使用的安全凭证就是密钥，包括SecretId和SecretKey，每个用户最多两对密钥

SecretId: 标识API调用者身份，就像用户名

SecretKey：验证API调用者身份，like 密码

用户需要严格保管好安全凭证，避免泄露

密钥管理中控制台可见的字段为： APPID（生成的两个密钥对的APPID相同）、密钥（ID和Key）、创建时间，最近访问时间，状态（2：有效， 3：禁用，4：已经删除）、操作

云API签名过程

按照OpenAPI业务接口文档，第三方用户可以直接直接访问相关的接口获取资源，首先访问的就是服务提供方的服务器，接口也就是服务器上Open的接口

比如tecent云的访问实例：

访问者访问需要提供公共参数和接口参数，访问者的SecretId 为 AKID…, SecretKey为GU5…

curl -X  POST https://cvm.tencentcloudapi.com \
-H "Authorization: TC3-HMAC-SHA256 Credential=AKID..../2023-01-01/cvm/tc3_request, SignedHeaders=content-type;host, Signature=22398u89hufahkgjaglkahhgaj
-H "ContentType: application/json; charset=utf-8"
-H "X-TC-Action: DescribeInstances" \
-H "X-TC-Timestamp: 1551113065" \
-H "X-TC-Version: 2017-03-12" \
-H "X-TC-Region: ap-guangzhou" \
-d '{"Limit": 1, "Filters": [{"Values": ["\u672a\u547d\u540d"], "Name": "instance-name"}]}'

按照这个请求，可以看到最重要的就是Authorization，其中的Credential代表的就是SecretID，标识身份，后面加上请求的Date/service/云固定结尾tc3_request，后面再跟上signheaders代表参与签名的头，就可以计算签名；

后面的signature就是签名串，服务端按照同样的过程签名和该signature对比验证是否篡改

签名的过程为：

拼接规范请求串 CanonicalRequest

CanonicalRequest =
    HTTPRequestMethod + '\n' +   	【请求方法】
    CanonicalURI + '\n' +  			【URI参数 /】
    CanonicalQueryString + '\n' +	 【查询字符串，post为空，get为？后部分】
    CanonicalHeaders + '\n' +		【参与签名的头部信息，按照key:value\n】
    SignedHeaders + '\n' + 【参与签名的头部， 就是key1;key2】
    HashedRequestPayload  【请求正文body】比如对正文SHA256哈希，得到signature，这里假设为35e...，Get请求为空】

得到规范的请求串

POST
/

content-type:application/json; charset=utf-8
host:cvm.tencentcloudapi.com

content-type;host
35e9c5b0e3ae67532d3c9f17ead6c90222632e5b1ff7f6e89887f1398934f064

拼接待签名字符串

签名串格式

StringToSign =
    Algorithm + \n +    【签名算法： SHA256]
    RequestTimestamp + \n +	 	【请求时间戳】
    CredentialScope + \n + 		【凭证范围： Data/service/tc3_REQUEST，   eg： /2023-01-01/cvm/tc3_request，cvm就是具体的产品】
    HashedCanonicalRequest   请求串【规范请求串再次SHA256得到的签名串】

按照该格式，就可以得出一个实例的签名字符串

TC3-HMAC-SHA256
1551113065
2019-02-25/cvm/tc3_request
5ffe6a04c0664d6b969fab9a13bdab201d63ee709638e2749d62a09ca18d7031

计算签名

签名密钥【计算得出】

SecretKey = "Gu5t9xGARNpq86cd98joQYCN3*******"
SecretDate = HMAC_SHA256("TC3" + SecretKey, Date)
SecretService = HMAC_SHA256(SecretDate, Service)
SecretSigning = HMAC_SHA256(SecretService, "tc3_request")

SecretKey就是用户自己持有的密钥Key，Date为访问的Date信息，Service就是请求的产品服务，比如cvm

这里的计算密钥过程，使用初始密钥Key 加入Date签名，再加入请求的服务再次签名，再将固定的结尾串tc3_request加入签名得到一个派生密钥

计算签名

将上面的派生密钥加入到待签名字符串中进行签名

Signature = HexEncode(HMAC_SHA256(SecretSigning, StringToSign))

拼接到Authorization中

Authorization就是用户访问OpenAPI最关键的信息，服务端不仅需要验证请求者身份和其对应的权限，还需要防止请求篡改

Authorization =
    Algorithm + ' ' +
    'Credential=' + SecretId + '/' + CredentialScope + ', ' +
    'SignedHeaders=' + SignedHeaders + ', ' +
    'Signature=' + Signature

Algorithm就是整个签名过程的签名算法，Credential 中包含的就是SecretId和CredentialScope 【date/service/ninetech_request】signedHeaders参与签名的头部， Signature就是签名的结果

import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.TimeZone;
import java.util.TreeMap;
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import javax.xml.bind.DatatypeConverter;

public class TencentCloudAPITC3Demo {
    private final static Charset UTF8 = StandardCharsets.UTF_8;
    private final static String SECRET_ID = "AKIDz8krbsJ5yKBZQpn74WFkmLPx3*******";
    private final static String SECRET_KEY = "Gu5t9xGARNpq86cd98joQYCN3*******";
    private final static String CT_JSON = "application/json; charset=utf-8";

    public static byte[] hmac256(byte[] key, String msg) throws Exception {
        Mac mac = Mac.getInstance("HmacSHA256");
        SecretKeySpec secretKeySpec = new SecretKeySpec(key, mac.getAlgorithm());
        mac.init(secretKeySpec);
        return mac.doFinal(msg.getBytes(UTF8));
    }

    public static String sha256Hex(String s) throws Exception {
        MessageDigest md = MessageDigest.getInstance("SHA-256");
        byte[] d = md.digest(s.getBytes(UTF8));
        return DatatypeConverter.printHexBinary(d).toLowerCase();
    }

    public static void main(String[] args) throws Exception {
        String service = "cvm";
        String host = "cvm.tencentcloudapi.com";
        String region = "ap-guangzhou";
        String action = "DescribeInstances";
        String version = "2017-03-12";
        String algorithm = "TC3-HMAC-SHA256";
        String timestamp = "1551113065";
        //String timestamp = String.valueOf(System.currentTimeMillis() / 1000);
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        // 注意时区，否则容易出错
        sdf.setTimeZone(TimeZone.getTimeZone("UTC"));
        String date = sdf.format(new Date(Long.valueOf(timestamp + "000")));

        // ************* 步骤 1：拼接规范请求串 *************
        String httpRequestMethod = "POST";
        String canonicalUri = "/";
        String canonicalQueryString = "";
        String canonicalHeaders = "content-type:application/json; charset=utf-8\n" + "host:" + host + "\n";
        String signedHeaders = "content-type;host";

        String payload = "{\"Limit\": 1, \"Filters\": [{\"Values\": [\"\\u672a\\u547d\\u540d\"], \"Name\": \"instance-name\"}]}";
        String hashedRequestPayload = sha256Hex(payload);
        String canonicalRequest = httpRequestMethod + "\n" + canonicalUri + "\n" + canonicalQueryString + "\n"
                + canonicalHeaders + "\n" + signedHeaders + "\n" + hashedRequestPayload;
        System.out.println(canonicalRequest);

        // ************* 步骤 2：拼接待签名字符串 *************
        String credentialScope = date + "/" + service + "/" + "tc3_request";
        String hashedCanonicalRequest = sha256Hex(canonicalRequest);
        String stringToSign = algorithm + "\n" + timestamp + "\n" + credentialScope + "\n" + hashedCanonicalRequest;
        System.out.println(stringToSign);

        // ************* 步骤 3：计算签名 *************
        byte[] secretDate = hmac256(("TC3" + SECRET_KEY).getBytes(UTF8), date);
        byte[] secretService = hmac256(secretDate, service);
        byte[] secretSigning = hmac256(secretService, "tc3_request");
        String signature = DatatypeConverter.printHexBinary(hmac256(secretSigning, stringToSign)).toLowerCase();
        System.out.println(signature);

        // ************* 步骤 4：拼接 Authorization *************
        String authorization = algorithm + " " + "Credential=" + SECRET_ID + "/" + credentialScope + ", "
                + "SignedHeaders=" + signedHeaders + ", " + "Signature=" + signature;
        System.out.println(authorization);

        TreeMap<String, String> headers = new TreeMap<String, String>();
        headers.put("Authorization", authorization);
        headers.put("Content-Type", CT_JSON);
        headers.put("Host", host);
        headers.put("X-TC-Action", action);
        headers.put("X-TC-Timestamp", timestamp);
        headers.put("X-TC-Version", version);
        headers.put("X-TC-Region", region);

        StringBuilder sb = new StringBuilder();
        sb.append("curl -X POST https://").append(host)
        .append(" -H \"Authorization: ").append(authorization).append("\"")
        .append(" -H \"Content-Type: application/json; charset=utf-8\"")
        .append(" -H \"Host: ").append(host).append("\"")
        .append(" -H \"X-TC-Action: ").append(action).append("\"")
        .append(" -H \"X-TC-Timestamp: ").append(timestamp).append("\"")
        .append(" -H \"X-TC-Version: ").append(version).append("\"")
        .append(" -H \"X-TC-Region: ").append(region).append("\"")
        .append(" -d '").append(payload).append("'");
        System.out.println(sb.toString());
    }
}

云API签名失败规范

签名是可能失败的，统一定义错误码类AuthFailure

SignatureExpire : 签名过期，timestamp 和接收到请求时间超过5min

SecretIdNotFound： 密钥不存在， 可能是密钥书写错误或者被禁用

SignatureFailure： 签名错误, 可能是SecretKey错误，就是内容不符合

TokenFailure： 临时证书Token错误

InvalidSecretId： 密钥非法， 类型错误...

Token 和长期密钥

按照腾讯云的intro， Token是安全凭证服务申请的临时的凭证，而密钥是长期有效的

而凭证服务也是直接调用系统的API达到，such as：

申请扮演角色： AssumeRole 【公共参数Action、Version、Region】，接口私有参数【RoleArn：角色资源描述，比如qcs::cam::uin/1234:roleName/testRoleName 、 RoleSessionName：临时会话名称、 DurationSeconds：临时证书有效期，default 7200s 、 Policy 、 ExternId、 Tags.N 、 SourceIdentity】，输出参数就包括Credentials 临时安全证书（Token： String、 TmpSecretId 临时证书密钥ID、 TmpSecretKey： key）、 ExpiredTime（时间戳过期时间）、Expiration（无效时间iso格式）、 RequestId（唯一请求ID，每次请求都有）
申请OIDC角色临时密钥： AssumeRoleWithWebIdentity 【三个公共参数、ProviderId：身份提供商名称、 webIdentityToken： IdP签发OIDC令牌、 RoleArn：角色描述名称、 RoleSessionName：会话名称、 DurationSeconds：有效期】，输出参数和上方一致
获取当前调用者身份信息： GetCallerIdentity ：支持主账号长期密钥、以及AssumeRole等临时密钥身份获取，输入参数就3个公共参数；输出参数包括【Arn 、 AccountId：主账号uin、 UserId：身份标识、 PrincipalId：密钥所属账号uin、 Type：身份类型、 RequestID】
获取联合身份临时凭证： GetFederationToken 【三个公共参数， Name：调用方名称自定义、 Policy（授予临时证书的CAM策略）、 DurationSeconds】；输出参数就是👆，临时的一个证书和其失效时间

公共参数

公共参数是标识用户和接口签名的参数，每一个接口访问都需要携带才能正常发起请求

公共参数需要统一放到HTTP Header请求头中

Action String X-TC-Action：操作的接口名称，比如查询服务器DescribeInstances
Timestamp： Integer X-TC-Timestamp：当前时间戳，如果与当前时间超过5min则过期
Version ： String X-TC-Version 操作的API版本，比如2023-01
Authorization： String 标准身份认证字段，包含内容详见上面👆，比如签名算法、签名凭证、参与签名的头部、签名生成的摘要【使用密钥Secret参与操作】
Token： String X-TC-Token, 安全凭证服务办法的临时安全凭证中的Token【注意是临时】，使用的时候也就是将SecretKey和ID替换为TmpSecretId和Key，使用长期密钥Secret时不设置该Token字段
Language： String（可选），X-TC-Language，接口返回语言，比如zh-CN、en-US
Region ： String （可选）地域

按照腾讯云的示例，开发者用户查询云服务器示例列表前10个，偏移量Offset=0，Limit = 10

https://cvm.tencentcloudapi.com/?Limit=10&Offset=0

Authorization: TC3-HMAC-SHA256 Credential=AKID********EXAMPLE/2018-10-09/cvm/tc3_request, SignedHeaders=content-type;host, Signature=5da7a33f6993f0614b047e5df4582db9e9bf4672ba50567dba16c6ccf174c474
Content-Type: application/x-www-form-urlencoded
Host: cvm.tencentcloudapi.com
X-TC-Action: DescribeInstances
X-TC-Version: 2017-03-12
X-TC-Timestamp: 1539084154
X-TC-Region: ap-guangzhou

请求头中最主要的就是Authorization，之后就是Content-type、host和公共参数（Action、version、timestamp、region）

除了公共参数，剩下的就是具体访问接口的具体的参数，类似上面的申请临时证书服务

OpenApi设计

Cfeng结合导师的讲解和腾讯云资料查看，对于OpenAPI的思考暂时如下：

首先需要的是统一、规范的接口标准，快速接入，统一对外的接口，最需要保证的就是接口安全性，利用密钥签名实现，同时不只是针对RPA项目，所以需要考虑复用性，减少对于其他内容的调用，低耦合

AppId、AppSecret

或者是SecretId和SecretKey，id标识用户，key为密码，接口请求会根据规则生成签名，服务器会验证签名

ID的生成只需要保证全局唯一即可，对应用户； AppSeret生成也简单，只要和APPID能够关联即可

sign签名

非对称加密算法：例如RSA 私钥加密，公钥解密；结合摘要算法，摘要后，私钥加密，公钥解密，可以用在签名中

摘要算法：例如MD5 不需要密钥不可逆，不能根据密文反推明文

签名：数据防止篡改，防止身份冒充

数据防止篡改： signature数据和计算数据相同，说明没有篡改，开放资源
身份防冒充：比如使用SHA256withRSA，将数据先进行SHA256计算，在使用RSA私钥加密，对方解密也是一样，先用RSA公钥解密，再计算

这里按照腾讯云的思路，用户可以申请密钥对，申请成功就拥有SecretId和SecretKey

公私钥接口提供方生成，把私钥交给请求方

这里参照腾讯云，同时参照的给出一个模拟代码，就是验证的过程

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);
    }

}

使用算法就是SHA256

timestamp 时间戳保证有效期

时间戳是一个重要手段，可以防止同一个请求参数被无限使用，比如验证5分钟有效期

long now = LocalDateTime.now().atZone(ZoneId.systemDefault()).toInstant().toEpochMilli();
    if ((now - Long.parseLong(timestamp)) / 1000 / 60 >= 5) {
        throw new Exception("请求过期！");
    }

nonce保证一次性，避免重放

接口请求方生成随机数，实现接口一次性有效，避免重放攻击

接口请求方每次请求都会随机生成一个不重复的nonce值，接口提供方可以使用存储容器来存储该nonce，请求到来查看缓存中是否包含【可以放redis，有效期5min即可，先校验是否过期，再校验是否重放】

String str = cache.getIfPresent(appId + "_" + nonce);
    if (Objects.nonNull(str)) {
        throw new Exception("请求失效！");
    }

黑白名单

这个针对的就是具体的运维过程了，可以对于某些IP进行黑白名单限制，降低风险

限流、熔断、降级

OpenAPI需要充分考虑限流、熔断、降级问题，需要约定清楚，保证系统的功能，特别就是限流的大小

合法性校验（参数）

像腾讯云一样，公共参数、接口参数，哪些参数必填，必填的业务参数、业务参数校验保证合法性

综合来看，OpenAPI起始就是以接口的方式公开系统资源，需要注意的就是安全性和设计的复用性

当前cfeng考虑的就是参照腾讯的设计来设计OpenAPI，使用SHA256， 需要做密钥管理和一个临时的证书管理，目前需要考虑的问题： 发放长期密钥时，如何保证安全性？ 长期密钥和token不同时使用，如何进一步保证密钥安全性？  密钥 和token 和refreshtoken的关系？
其实最核心的问题就是： 我给用户发放密钥时（通过HTTP），怎么保证不被其他人盗取

接下来就是开放平台的规范化设计了🌳