企业自建应用鉴权（JWT）

class SignatureUtil
{
    private static $secret_id = '';  // SecretId
    private static $secret_key = ''; // SecretKey

    public static function setSecretIdAndKey($secret_id, $secret_key)
    {
        self::$secret_id = $secret_id;
        self::$secret_key = $secret_key;
    }

    public static function getSecretId()
    {
        return self::$secret_id;
    }

    /**
     * @param $header = [
     * 'X-TC-Nonce' => '',  // X-TC-Nonce请求头，随机数
     * 'X-TC-Timestamp' => '', // X-TC-Timestamp请求头，当前时间的秒级时间戳
     * 'URI' => ''  //请求uri，eg：/v1/meetings,
     * ];
     * @param $body   请求体，没有的设为空串
     * @param $method  请求方式 字符串 "POST","GET"
     */
    public static function sign($header, $body, $method)
    {
        if (empty(self::$secret_id) || empty(self::$secret_key)) {
            return null;
        }
        $secret_id = self::$secret_id;
        $header_string = "X-TC-Key={$secret_id}&X-TC-Nonce={$header['X-TC-Nonce']}&X-TC-Timestamp={$header['X-TC-Timestamp']}";
        $str_to_sign = "{$method}\\n{$header_string}\\n{$header['URI']}\\n{$body}";
        $hash = hash_hmac('sha256', $str_to_sign, self::$secret_key);
        return base64_encode($hash);
    }
}


/**
 * 生成签名
 *
 * @param secretId 邮件下发的secret_id
 * @param secretKey 邮件下发的secret_key
 * @param httpMethod http请求方法 GET/POST/PUT等
 * @param headerNonce X-TC-Nonce请求头，随机数
 * @param headerTimestamp X-TC-Timestamp请求头，当前时间的秒级时间戳
 * @param requestUri 请求uri，eg：/v1/meetings
 * @param requestBody 请求体，没有的设为空串
 * @return 签名，需要设置在请求头X-TC-Signature中
 */
func DoSignature(secretId string, secretKey string, httpMethod string, headerNonce string, headerTimestamp string, requestUri string, requestBody string) string {
    headSignStr := fmt.Sprintf("X-TC-Key=%s&X-TC-Nonce=%s&X-TC-Timestamp=%s",
         secretId, headerNonce, headerTimestamp)
    signStr := fmt.Sprintf("%s\\n%s\\n%s\\n%s", httpMethod, headSignStr, requestUri, requestBody)
    h := hmac.New(sha256.New, []byte(secretKey))
    h.Write([]byte(signStr))
    sha := hex.EncodeToString(h.Sum([]byte{}))
    signBase64 := base64.StdEncoding.EncodeToString([]byte(sha))
    return signBase64
}


def sign(secretId, secretKey, httpMethod, headerNonce, headerTimestamp, requestUri, requestBody):
    tobeSig = "{0}\\nX-TC-Key={1}&X-TC-Nonce={2}&X-TC-Timestamp={3}\\n{4}\\n{5}".format(
        httpMethod, secretId,  headerNonce,  headerTimestamp,  requestUri,  requestBody)
    signature = hmac.new(secretKey.encode(
        'utf-8'), tobeSig.encode('utf-8'), digestmod='sha256').hexdigest()
    return base64.b64encode(signature.encode('utf-8'))


#include <iostream>
#include <string>
#include <openssl/hmac.h>
#include <openssl/buffer.h>

using namespace std;

//hmac-sha256
int HmacEncode(const char * key, unsigned int key_length,
               const char * input, unsigned int input_length,
               unsigned char * &output, unsigned int &output_length) {
    const EVP_MD * engine = EVP_sha256();
    output = (unsigned char*)malloc(EVP_MAX_MD_SIZE);
    HMAC_CTX *ctx = HMAC_CTX_new();
    HMAC_Init_ex(ctx, key, key_length, engine, NULL);
    HMAC_Update(ctx, (unsigned char*)input, input_length);
    HMAC_Final(ctx, output, &output_length);
    HMAC_CTX_free(ctx);
    return 0;
}

//base64
char * Base64Encode(const char * input, int length)
{
    BIO * bmem = NULL;
    BIO * b64 = NULL;
    BUF_MEM * bptr = NULL;
    b64 = BIO_new(BIO_f_base64());
    BIO_set_flags(b64, BIO_FLAGS_BASE64_NO_NL);
    bmem = BIO_new(BIO_s_mem());
    b64 = BIO_push(b64, bmem);
    BIO_write(b64, input, length);
    BIO_flush(b64);
    BIO_get_mem_ptr(b64, &bptr);
    char * buff = (char *)malloc(bptr->length + 1);
    memcpy(buff, bptr->data, bptr->length);
    buff[bptr->length] = 0;
    BIO_free_all(b64);
    return buff;
}

//unsigned char 转 十六进制字符串
void byte_to_hex( const unsigned char* source, char* dest, int sourceLen) {
    short i;
    unsigned char highByte, lowByte;
    for (i = 0; i < sourceLen; i++) {
        highByte = source[i] >> 4;
        lowByte = source[i] & 0x0f;
        highByte += 0x30;
        if (highByte > 0x39)
            dest[i * 2] = highByte + 0x07;
        else
            dest[i * 2] = highByte;
        lowByte += 0x30;
        if (lowByte > 0x39)
            dest[i * 2 + 1] = lowByte + 0x07;
        else
            dest[i * 2 + 1] = lowByte;
    }
    return;
}

/**
 * 生成签名
 *
 * @param secretId 邮件下发的secret_id
 * @param secretKey 邮件下发的secret_key
 * @param httpMethod http请求方法 GET/POST/PUT等
 * @param headerNonce X-TC-Nonce请求头，随机数
 * @param headerTimestamp X-TC-Timestamp请求头，当前时间的秒级时间戳
 * @param requestUri 请求uri，eg：/v1/meetings
 * @param requestBody 请求体，没有的设为空串
 * @return 签名，需要设置在请求头X-TC-Signature中
 */
string sign(string secretId, string secretKey, string httpMethod, string headerNonce, string headerTimestamp, string requestUri, string requestBody)
{
    string tobeSig = httpMethod + "\\nX-TC-Key=" + secretId + "&X-TC-Nonce=" + headerNonce + "&X-TC-Timestamp=" + headerTimestamp + "\\n" + requestUri + "\\n" + requestBody;
    unsigned char* mac = NULL;
    unsigned int mac_length = 0;
    HmacEncode(secretKey.c_str(), secretKey.length(), tobeSig.c_str(), tobeSig.length(), mac, mac_length);
    char* dest;
    byte_to_hex(mac,dest,mac_length);
    string str = dest;
    transform(str.begin(),str.end(),str.begin(),::tolower);
    return Base64Encode(str.c_str(), 64);
}



/**
  * 生成签名
  *
  * @param secretId 邮件下发的secret_id
  * @param secretKey 邮件下发的secret_key
  * @param httpMethod http请求方法 GET/POST/PUT等
  * @param headerNonce X-TC-Nonce请求头，随机数
  * @param headerTimestamp X-TC-Timestamp请求头，当前时间的秒级时间戳
  * @param requestUri 请求uri，eg：/v1/meetings
  * @param requestBody 请求体，没有的设为空串
  * @return 签名，需要设置在请求头X-TC-Signature中
*/
private static string sign(string secretId, string secretKey, string httpMethod, string headerNonce, string headerTimestamp, string requestUri, string requestBody)
{
     String tobeSig =
        httpMethod + "\\nX-TC-Key=" + secretId + "&X-TC-Nonce=" + headerNonce + "&X-TC-Timestamp=" + headerTimestamp + "\\n" + requestUri + "\\n" + requestBody;
     var encoding = System.Text.Encoding.UTF8;
     byte[] keyByte = encoding.GetBytes(secretKey);
     byte[] messageBytes = encoding.GetBytes(tobeSig);
     using (var hmacsha256 = new HMACSHA256(keyByte))
     {
          byte[] hashmessage = hmacsha256.ComputeHash(messageBytes);
          var b16 = BitConverter.ToString(hashmessage).Replace("-", "").ToLower();
          return Convert.ToBase64String(encoding.GetBytes(b16));
     }
}