API 接入指引

package tms

import (
    "crypto/hmac"
    "crypto/sha256"
    "encoding/base64"
    "encoding/hex"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
    "strconv"
    "strings"
    "time"
)

type textmods struct {
    Content string
}

func sha256hexs(s string) string {
    b := sha256.Sum256([]byte(s))
    return hex.EncodeToString(b[:])
}

func hmacsha256s(s, key string) string {
    hashed := hmac.New(sha256.New, []byte(key))
    hashed.Write([]byte(s))
    return string(hashed.Sum(nil))
}

func DetectTextSingles() {
    secretId := ""                    // 密钥ID
    secretKey := ""                   // 密钥Key
    host := "tms.tencentcloudapi.com" // 接口域名
    algorithm := "TC3-HMAC-SHA256"
    service := "tms"
    version := "2020-12-29" // 版本为固定值
    action := "TextModeration"
    region := "ap-guangzhou" // 地域
    var timestamp int64 = time.Now().Unix()

    // step 1: build canonical request string
    httpRequestMethod := "POST"
    canonicalURI := "/"
    canonicalQueryString := ""
    canonicalHeaders := "content-type:application/json; charset=utf-8\\n" + "host:" + host + "\\n"
    signedHeaders := "content-type;host"
    var a = textmods{
        Content: base64.StdEncoding.EncodeToString([]byte("测试文本内容")), // 接口入参
    }
    b, err := json.Marshal(a)
    if err != nil {
        fmt.Print(err.Error())
        return
    }
    payload := string(b)
    hashedRequestPayload := sha256hexs(payload)
    canonicalRequest := fmt.Sprintf("%s\\n%s\\n%s\\n%s\\n%s\\n%s",
        httpRequestMethod,
        canonicalURI,
        canonicalQueryString,
        canonicalHeaders,
        signedHeaders,
        hashedRequestPayload)
    // fmt.Println(canonicalRequest)

    // step 2: build string to sign
    date := time.Unix(timestamp, 0).UTC().Format("2006-01-02")
    credentialScope := fmt.Sprintf("%s/%s/tc3_request", date, service)
    hashedCanonicalRequest := sha256hexs(canonicalRequest)
    string2sign := fmt.Sprintf("%s\\n%d\\n%s\\n%s",
        algorithm,
        timestamp,
        credentialScope,
        hashedCanonicalRequest)
    // fmt.Println(string2sign)

    // step 3: sign string
    secretDate := hmacsha256s(date, "TC3"+secretKey)
    secretService := hmacsha256s(service, secretDate)
    secretSigning := hmacsha256s("tc3_request", secretService)
    signature := hex.EncodeToString([]byte(hmacsha256s(string2sign, secretSigning)))
    // fmt.Println(signature)

    // step 4: build authorization
    authorization := fmt.Sprintf("%s Credential=%s/%s, SignedHeaders=%s, Signature=%s",
        algorithm,
        secretId,
        credentialScope,
        signedHeaders,
        signature)

    req, _ := http.NewRequest("POST", "https://"+host, strings.NewReader(payload))
    req.Header.Set("Authorization", authorization)
    req.Header.Set("Content-Type", "application/json; charset=utf-8")
    req.Header.Set("Host", host)
    req.Header.Set("X-TC-Action", action)
    req.Header.Set("X-TC-Timestamp", strconv.FormatInt(timestamp, 10))
    req.Header.Set("X-TC-Version", version)
    req.Header.Set("X-TC-Region", region)

    resp, err := (&http.Client{}).Do(req)
    if err != nil {
        fmt.Print(err.Error())
        return
    }
    defer resp.Body.Close()

    respByte, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(respByte))
}

#!/usr/bin/env python3
# -*- coding:utf-8 -*-
import hashlib
import hmac
import json
import base64
import time
from datetime import datetime
import requests
from concurrent.futures import ThreadPoolExecutor


secret_id = "" # 密钥ID
secret_key = "" # 密钥Key


service = "tms"
host = "tms.tencentcloudapi.com" # 接口域名
endpoint = "https://" + host
region = 'ap-guangzhou' # 地域
version = "2020-12-29" # 版本为固定值
algorithm = "TC3-HMAC-SHA256"


def do_action(action, params):
    timestamp = int(time.time())
    day = datetime.utcfromtimestamp(timestamp).strftime("%Y-%m-%d")

    # ************* 步骤 1：拼接规范请求串 *************
    http_request_method = "POST"
    canonical_url = "/"
    canonical_querystring = ""
    ct = "application/json; charset=utf-8"
    payload = json.dumps(params)
    canonical_headers = "content-type:%s\\nhost:%s\\n" % (ct, host)
    signed_headers = "content-type;host"
    hashed_request_payload = hashlib.sha256(
        payload.encode("utf-8")).hexdigest()
    canonical_request = (http_request_method + "\\n" +
                         canonical_url + "\\n" +
                         canonical_querystring + "\\n" +
                         canonical_headers + "\\n" +
                         signed_headers + "\\n" +
                         hashed_request_payload)
    # print(canonical_request)

    # ************* 步骤 2：拼接待签名字符串 *************
    credential_scope = day + "/" + service + "/" + "tc3_request"
    hashed_canonical_request = hashlib.sha256(
        canonical_request.encode("utf-8")).hexdigest()
    string_to_sign = (algorithm + "\\n" +
                      str(timestamp) + "\\n" +
                      credential_scope + "\\n" +
                      hashed_canonical_request)

    # print(string_to_sign)

    secret_date = sign(("TC3" + secret_key).encode("utf-8"), day)
    secret_service = sign(secret_date, service)
    secret_signing = sign(secret_service, "tc3_request")
    signature = hmac.new(secret_signing, string_to_sign.encode(
        "utf-8"), hashlib.sha256).hexdigest()
    # print(signature)

    # ************* 步骤 4：拼接 Authorization *************
    authorization = (algorithm + " " +
                     "Credential=" + secret_id + "/" + credential_scope + ", " +
                     "SignedHeaders=" + signed_headers + ", " +
                     "Signature=" + signature)
    # print(authorization)

    headers = {
        "Authorization": authorization,
        "Content-Type": "application/json; charset=utf-8",
        "Host": host,
        "X-TC-Action": action,
        "X-TC-Timestamp": str(timestamp),
        "X-TC-Version": version,
        "X-TC-Region": region
    }

    # 发送请求
    resp = requests.post(url=endpoint, data=payload, headers=headers)
    return resp


# 计算签名摘要函数
def sign(key, msg):
    return hmac.new(key, msg.encode("utf-8"), hashlib.sha256).digest()


def image_detect(params):
    action = "TextModeration"
    resp = do_action(action, params)

    return resp.text


if __name__ == "__main__":

    params = []
    content = "" # 接口参数
    b4content = base64.b64encode(content.encode()).decode()
    p = {
        'BizType': 'default',
        'Content': b4content
    }
    params.append(p)
    executor = ThreadPoolExecutor(max_workers=1)
    resps = executor.map(image_detect, params)
    for resp in resps:
        print(resp)


<?php 
//简单的后端demo
// 接口入参
$Content='';
$BizType='';

$time=time();
$Nonce=rand();
$Action='TextModeration'; // 接口名称
$Version='2020-12-29';
$Region='ap-guangzhou';

//根据实际需求填写 SecretId 和 secretKey
$SecretId='';
$secretKey='';

//验签过程
$param["Nonce"] = $Nonce;
$param["Timestamp"] = $time;
$param["Region"] = $Region;
$param["SecretId"] = $SecretId;
$param["Action"] = $Action;
$param["Version"] = $Version;
$param["Content"] = $Content;
$param["BizType"] = $BizType;
ksort($param);
$signStr = "POSTtms.tencentcloudapi.com/?";
foreach ( $param as $key => $value ) {
    $signStr = $signStr . $key . "=" . $value . "&";
}
$signStr = substr($signStr, 0, -1);
$signature = base64_encode(hash_hmac("sha1", $signStr,$secretKey, true));
//$signature=urlencode($signature);//文档要求必须先urlencode

//POST数据
$post_data = array(
'Action' => $Action,
'Nonce' =>$Nonce,
'SecretId'=>$SecretId,
'Signature'=>$signature,//签名
'Content' =>$Content,
'BizType' =>$BizType,
'Region' =>$Region,
'Timestamp' =>$time,
'Version' =>$Version,
);

//POST请求
$url='https://tms.tencentcloudapi.com/';
$query = http_build_query($post_data);
$options = array(
'http' => array(
'method' => 'POST',
'header' => 'Content-type:application/x-www-form-urlencoded',
'content' => $query,
'timeout' => 15 * 60 // 超时时间（单位:s）
)
);
$context = stream_context_create($options);
$result = file_get_contents($url,false,$context);

$data_arr['code']=1;
$data_arr['result']=$result;
$data_arr['signature']=$signature;

header('content-type:application/json');
echo json_encode($data_arr);
exit();