tencent cloud

Feedback

Signature v3

Last updated: 2022-08-02 15:42:22
TencentCloud API authenticates every single request, i.e., the request must be signed using the security credentials in the designated steps. Each request has to contain the signature information (Signature) in the common request parameters and be sent in the specified way and format. ## Applying for Security Credentials The security credential used in this document is a key, which includes a SecretId and a SecretKey. Each user can have up to two pairs of keys. * SecretId: Used to identify the API caller, which is just like a username. * SecretKey: Used to authenticate the API caller, which is just like a password. * **You must keep your security credentials private and avoid disclosure; otherwise, your assets may be compromised. If they are disclosed, please disable them as soon as possible.** You can apply for the security credentials through the following steps: 1. Log in to the [Tencent Cloud Console](https://console.tencentcloud.com/). 2. Go to the [TencentCloud API Key](https://console.tencentcloud.com/capi) console page. 3. On the [TencentCloud API Key](https://console.tencentcloud.com/capi) page, click **Create** to create a SecretId/SecretKey pair. ## Using the Resources for Developers TencentCloud API comes with SDKs for seven commonly used programming languages, including [Python](https://github.com/TencentCloud/tencentcloud-sdk-python-intl-en), [Java](https://github.com/TencentCloud/tencentcloud-sdk-java-intl-en), [PHP](https://github.com/TencentCloud/tencentcloud-sdk-php-intl-en), [Go](https://github.com/TencentCloud/tencentcloud-sdk-go-intl-en), [NodeJS](https://github.com/TencentCloud/tencentcloud-sdk-nodejs-intl-en) and [.NET](https://github.com/TencentCloud/tencentcloud-sdk-dotnet-intl-en). In addition, it provides [API Explorer](https://console.tencentcloud.com/api/explorer?SignVersion=api3v3) which enables online call, signature verification, and SDK code generation. If you have any troubles calculating a signature, consult these resources. ## TC3-HMAC-SHA256 Signature Algorithm Compatible with the previous HmacSHA1 and HmacSHA256 signature algorithms, the TC3-HMAC-SHA256 signature algorithm is more secure and supports larger requests and JSON format with better performance. We recommend using TC3-HMAC-SHA256 to calculate the signature. TencentCloud API supports both GET and POST requests. For the GET method, only the Content-Type: application/x-www-form-urlencoded protocol format is supported. For the POST method, two protocol formats, Content-Type: application/json and Content-Type: multipart/form-data, are supported. The JSON format is supported by default for all business APIs, and the multipart format is supported only for specific business APIs. In this case, the API cannot be called in JSON format. See the specific business API documentation for more information. The POST method is recommended, as there is no difference in the results of both the methods, but the GET method only supports request packets up to 32 KB. The following uses querying the list of CVM instances in the Guangzhou region as an example to describe the steps of signature splicing. We chose this API because: 1. CVM is activated by default, and this API is often used; 2. It is read-only and does not change the status of existing resources; 3. It covers many types of parameters, which allows it to be used to demonstrate how to use arrays containing data structures. In the example, we try to choose common parameters and API parameters that are prone to mistakes. When you actually call an API, please use parameters based on the actual conditions. The parameters vary by API. Do not copy the parameters and values in this example. Assuming that your SecretId and SecretKey are `AKIDz8krbsJ5yKBZQpn74WFkmLPx3*******` and `Gu5t9xGARNpq86cd98joQYCN3*******`, respectively, if you want to view the status of the instance in the Guangzhou region whose CVM instance name is "unnamed" and have only one data entry returned, then the request may be: ``` curl -X POST https://cvm.tencentcloudapi.com \ -H "Authorization: TC3-HMAC-SHA256 Credential=AKIDz8krbsJ5yKBZQpn74WFkmLPx3*******/2019-02-25/cvm/tc3_request, SignedHeaders=content-type;host, Signature=c492e8e41437e97a620b728c301bb8d17e7dc0c17eeabce80c20cd70fc3a78ff" \ -H "Content-Type: application/json; charset=utf-8" \ -H "Host: cvm.tencentcloudapi.com" \ -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": ["unnamed"], "Name": "instance-name"}]}' ``` The signature calculation process is explained in detail below. ### 1. Concatenating the CanonicalRequest String Concatenate the canonical request string (CanonicalRequest) in the following pseudocode format: ``` CanonicalRequest = HTTPRequestMethod + '\n' + CanonicalURI + '\n' + CanonicalQueryString + '\n' + CanonicalHeaders + '\n' + SignedHeaders + '\n' + HashedRequestPayload ``` | Field Name | Explanation | |-|-| | HTTPRequestMethod | HTTP request method (GET or POST). This example uses `POST`. | | CanonicalURI | URI parameter. Slash ("/") is used for API 3.0. | | CanonicalQueryString | The query string in the URL of the originating HTTP request. This is always an empty string “” for POST requests, and is the string after the question mark (?) for GET requests. For example: Limit=10&Offset=0。
Note: `CanonicalQueryString` must be URL-encoded, referencing [RFC3986](https://tools.ietf.org/html/rfc3986), the UTF8 character set. We recommend using the programming language library. All special characters must be encoded and capitalized. | | CanonicalHeaders | Header information for signature calculation, including at least two headers of `host` and `content-type`. Custom headers can be added to participate in the signature process to improve the uniqueness and security of the request.
Concatenation rules:
  1. Both the key and value of the header should be converted to lowercase with the leading and trailing spaces removed, so they are concatenated in the format of key:value\n format;
  2. If there are multiple headers, they should be sorted in ASCII ascending order by the header keys (lowercase).
The calculation result in this example is `content-type:application/json; charset=utf-8\nhost:cvm.tencentcloudapi.com\n`.
Note: `content-type` must match the actually sent content. In some programming languages, a charset value would be added even if it is not specified. In this case, the request sent is different from the one signed, and the sever will return an error indicating that signature verification failed. | | SignedHeaders | Header information for signature calculation, indicating which headers of the request participate in the signature process (they must each individually correspond to the headers in CanonicalHeaders). `Content-type` and `host` are required headers.
Concatenation rules:
  1. Both the key and value of the header should be converted to lowercase;
  2. If there are multiple headers, they should be sorted in ASCII ascending order by the header keys (lowercase) and separated by semicolons (;).
The value in this example is `content-type;host` | | HashedRequestPayload | Hash value of the request payload (i.e., the body, such as `{"Limit": 1, "Filters": [{"Values": ["unnamed"], "Name": "instance-name"}]}` in this example). The pseudocode for calculation is Lowercase(HexEncode(Hash.SHA256(RequestPayload))) by SHA256 hashing the payload of the HTTP request, performing hexadecimal encoding, and finally converting the encoded string to lowercase letters. For GET requests, `RequestPayload` is always an empty string. The calculation result in this example is `99d58dfbc6745f6747f36bfca17dee5e6881dc0428a0a36f96199342bc5b4907`. | According to the rules above, the `CanonicalRequest` string obtained in the example is as follows: ``` POST / content-type:application/json; charset=utf-8 host:cvm.tencentcloudapi.com content-type;host 99d58dfbc6745f6747f36bfca17dee5e6881dc0428a0a36f96199342bc5b4907 ``` ### 2. Concatenating the String to Be Signed The string to sign is concatenated as follows: ``` StringToSign = Algorithm + \n + RequestTimestamp + \n + CredentialScope + \n + HashedCanonicalRequest ``` | Field Name | Explanation | |-|-| | Algorithm | Signature algorithm, which is currently always `TC3-HMAC-SHA256`. | | RequestTimestamp | Request timestamp, i.e., the value of the common parameter `X-TC-Timestamp` in the request header, which is the UNIX timestamp of the current time in seconds, such as `1551113065` in this example. | | CredentialScope | Scope of the credential in the format of `Date/service/tc3_request`, including the date, requested service and termination string (tc3_request). **`Date` is a date in UTC time, whose value should match the UTC date converted by the common parameter `X-TC-Timestamp`;** `service` is the product name, which should match the domain name of the product called. The calculation result in this example is `2019-02-25/cvm/tc3_request`. | | HashedCanonicalRequest | Hash value of the CanonicalRequest string concatenated in the steps above. The pseudocode for calculation is Lowercase(HexEncode(Hash.SHA256(CanonicalRequest))). The calculation result in this example is `2815843035062fffda5fd6f2a44ea8a34818b0dc46f024b8b3786976a3adda7a`. | >Note: > 1. Date has to be calculated from the timestamp "X-TC-Timestamp" and the time zone is UTC+0. If you add the system's local time zone information (such as UTC+8), calls can succeed both day and night but will definitely fail at 00:00. For example, if the timestamp is 1551113065 and the time in UTC+8 is 2019-02-26 00:44:25, the UTC+0 date in the calculated Date value should be 2019-02-25 instead of 2019-02-26. > 2. Timestamp must be the same as your current system time, and your system time and standard time must be synced; if the difference between Timestamp and your current system time is larger than five minutes, the request will fail. If your system time is out of sync with the standard time for a while, the request will fail and return a signature expiration error. According to the preceding rules, the string to be signed obtained in the example is as follows: ``` TC3-HMAC-SHA256 1551113065 2019-02-25/cvm/tc3_request 2815843035062fffda5fd6f2a44ea8a34818b0dc46f024b8b3786976a3adda7a ``` ### 3. Calculating the Signature 1) Calculate the derived signature key with the following pseudocode: ``` SecretKey = "Gu5t9xGARNpq86cd98joQYCN3*******" SecretDate = HMAC_SHA256("TC3" + SecretKey, Date) SecretService = HMAC_SHA256(SecretDate, Service) SecretSigning = HMAC_SHA256(SecretService, "tc3_request") ``` | Field Name | Explanation | |-|-| | SecretKey | The original SecretKey, i.e., `Gu5t9xGARNpq86cd98joQYCN3*******`. | | Date | The Date field information in `Credential`, such as `2019-02-25` in this example. | | Service | Value in the Service field in `Credential`, such as `cvm` in this example. | 2) Calculate the signature with the following pseudocode: ``` Signature = HexEncode(HMAC_SHA256(SecretSigning, StringToSign)) ``` ### 4. Concatenating the Authorization The Authorization is concatenated as follows: ``` Authorization = Algorithm + ' ' + 'Credential=' + SecretId + '/' + CredentialScope + ', ' + 'SignedHeaders=' + SignedHeaders + ', ' + 'Signature=' + Signature ``` | Field Name | Explanation | |-|-| | Algorithm | Signature algorithm, which is always `TC3-HMAC-SHA256`. | | SecretId | The SecretId in the key pair, i.e., `AKIDz8krbsJ5yKBZQpn74WFkmLPx3*******`. | | CredentialScope | Credential scope (see above). The calculation result in this example is `2019-02-25/cvm/tc3_request`. | | SignedHeaders | Header information for signature calculation (see above), such as `content-type;host` in this example. | | Signature | Signature value. The calculation result in this example is `c492e8e41437e97a620b728c301bb8d17e7dc0c17eeabce80c20cd70fc3a78ff`. | According to the rules above, the value obtained in the example is: ``` TC3-HMAC-SHA256 Credential=AKIDz8krbsJ5yKBZQpn74WFkmLPx3*******/2019-02-25/cvm/tc3_request, SignedHeaders=content-type;host, Signature=c492e8e41437e97a620b728c301bb8d17e7dc0c17eeabce80c20cd70fc3a78ff ``` The following example shows a finished authorization header: ``` POST https://cvm.tencentcloudapi.com/ Authorization: TC3-HMAC-SHA256 Credential=AKIDz8krbsJ5yKBZQpn74WFkmLPx3*******/2019-02-25/cvm/tc3_request, SignedHeaders=content-type;host, Signature=c492e8e41437e97a620b728c301bb8d17e7dc0c17eeabce80c20cd70fc3a78ff Content-Type: application/json; charset=utf-8 Host: cvm.tencentcloudapi.com X-TC-Action: DescribeInstances X-TC-Version: 2017-03-12 X-TC-Timestamp: 1551113065 X-TC-Region: ap-guangzhou {"Limit": 1, "Filters": [{"Values": ["unnamed"], "Name": "instance-name"}]} ``` ### 5. Signature Demo When calling API 3.0, you are recommended to use the corresponding Tencent Cloud SDK 3.0 which encapsulates the signature process, enabling you to focus on only the specific APIs provided by the product when developing. See [SDK Center](https://www.tencentcloud.com/document/product/494) for more information. Currently, the following programming languages are supported: * [Python](https://github.com/TencentCloud/tencentcloud-sdk-python-intl-en) * [Java](https://github.com/TencentCloud/tencentcloud-sdk-java-intl-en) * [PHP](https://github.com/TencentCloud/tencentcloud-sdk-php-intl-en) * [Go](https://github.com/TencentCloud/tencentcloud-sdk-go-intl-en) * [NodeJS](https://github.com/TencentCloud/tencentcloud-sdk-nodejs-intl-en) * [.NET](https://github.com/TencentCloud/tencentcloud-sdk-dotnet-intl-en) To further explain the signing process, we will use a programming language to implement the process described above. The request domain name, API and parameter values in the sample are used here. This goal of this example is only to provide additional clarification for the signature process, please see the SDK for actual usage. The final output URL might be: https://cvm.tencentcloudapi.com/?Action=DescribeInstances&InstanceIds.0=ins-09dx96dg&Limit=20&Nonce=11886&Offset=0&Region=ap-guangzhou&SecretId=AKIDz8krbsJ5yKBZQpn74WFkmLPx3*******&Signature=EliP9YW3pW28FpsEdkXt%2F%2BWcGeI%3D&Timestamp=1465185768&Version=2017-03-12. Note: The key in the example is fictitious, and the timestamp is not the current time of the system, so if this URL is opened in the browser or called using commands such as curl, an authentication error will be returned: Signature expired. In order to get a URL that can work properly, you need to replace the SecretId and SecretKey in the example with your real credentials and use the current time of the system as the Timestamp. Note: In the example below, even if you use the same programming language, the order of the parameters in the URL may be different for each execution. However, the order does not matter, as long as all the parameters are included in the URL and the signature is calculated correctly. Note: The following code is only applicable to API 3.0. It cannot be directly used in other signature processes. Even with an older API, signature calculation errors may occur due to the differences in details. Please refer to the corresponding documentation. #### Java ``` 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"); // Pay attention to the time zone; otherwise, errors may occur sdf.setTimeZone(TimeZone.getTimeZone("UTC")); String date = sdf.format(new Date(Long.valueOf(timestamp + "000"))); // ************* Step 1: Concatenate the CanonicalRequest string ************* 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\": [\"unnamed\"], \"Name\": \"instance-name\"}]}"; String hashedRequestPayload = sha256Hex(payload); String canonicalRequest = httpRequestMethod + "\n" + canonicalUri + "\n" + canonicalQueryString + "\n" + canonicalHeaders + "\n" + signedHeaders + "\n" + hashedRequestPayload; System.out.println(canonicalRequest); // ************* Step 2: Concatenate the string to sign ************* String credentialScope = date + "/" + service + "/" + "tc3_request"; String hashedCanonicalRequest = sha256Hex(canonicalRequest); String stringToSign = algorithm + "\n" + timestamp + "\n" + credentialScope + "\n" + hashedCanonicalRequest; System.out.println(stringToSign); // ************* Step 3: Calculate the signature ************* 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); // ************* Step 4: Concatenate the Authorization ************* String authorization = algorithm + " " + "Credential=" + SECRET_ID + "/" + credentialScope + ", " + "SignedHeaders=" + signedHeaders + ", " + "Signature=" + signature; System.out.println(authorization); TreeMap headers = new TreeMap(); 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()); } } ``` #### Python ``` # -*- coding: utf-8 -*- import hashlib, hmac, json, os, sys, time from datetime import datetime # Key Parameters secret_id = "AKIDz8krbsJ5yKBZQpn74WFkmLPx3*******" secret_key = "Gu5t9xGARNpq86cd98joQYCN3*******" service = "cvm" host = "cvm.tencentcloudapi.com" endpoint = "https://" + host region = "ap-guangzhou" action = "DescribeInstances" version = "2017-03-12" algorithm = "TC3-HMAC-SHA256" #timestamp = int(time.time()) timestamp = 1551113065 date = datetime.utcfromtimestamp(timestamp).strftime("%Y-%m-%d") params = {"Limit": 1, "Filters": [{"Name": "instance-name", "Values": ["unnamed"]}]} # ************* Step 1: Concatenate the CanonicalRequest string ************* http_request_method = "POST" canonical_uri = "/" 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_uri + "\n" + canonical_querystring + "\n" + canonical_headers + "\n" + signed_headers + "\n" + hashed_request_payload) print(canonical_request) # ************* Step 2: Concatenate the string to sign ************* credential_scope = date + "/" + 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) # ************* Step 3: Calculate the Signature ************* # Function for computing signature digest def sign(key, msg): return hmac.new(key, msg.encode("utf-8"), hashlib.sha256).digest() secret_date = sign(("TC3" + secret_key).encode("utf-8"), date) 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) # ************* Step 4: Concatenate the Authorization ************* authorization = (algorithm + " " + "Credential=" + secret_id + "/" + credential_scope + ", " + "SignedHeaders=" + signed_headers + ", " + "Signature=" + signature) print(authorization) print('curl -X POST ' + endpoint + ' -H "Authorization: ' + authorization + '"' + ' -H "Content-Type: application/json; charset=utf-8"' + ' -H "Host: ' + host + '"' + ' -H "X-TC-Action: ' + action + '"' + ' -H "X-TC-Timestamp: ' + str(timestamp) + '"' + ' -H "X-TC-Version: ' + version + '"' + ' -H "X-TC-Region: ' + region + '"' + " -d '" + payload + "'") ``` #### Golang ``` package main import ( "crypto/hmac" "crypto/sha256" "encoding/hex" "fmt" "time" ) func sha256hex(s string) string { b := sha256.Sum256([]byte(s)) return hex.EncodeToString(b[:]) } func hmacsha256(s, key string) string { hashed := hmac.New(sha256.New, []byte(key)) hashed.Write([]byte(s)) return string(hashed.Sum(nil)) } func main() { secretId := "AKIDz8krbsJ5yKBZQpn74WFkmLPx3*******" secretKey := "Gu5t9xGARNpq86cd98joQYCN3*******" host := "cvm.tencentcloudapi.com" algorithm := "TC3-HMAC-SHA256" service := "cvm" version := "2017-03-12" action := "DescribeInstances" region := "ap-guangzhou" //var timestamp int64 = time.Now().Unix() var timestamp int64 = 1551113065 // 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" payload := `{"Limit": 1, "Filters": [{"Values": ["unnamed"], "Name": "instance-name"}]}` hashedRequestPayload := sha256hex(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 := sha256hex(canonicalRequest) string2sign := fmt.Sprintf("%s\n%d\n%s\n%s", algorithm, timestamp, credentialScope, hashedCanonicalRequest) fmt.Println(string2sign) // step 3: sign string secretDate := hmacsha256(date, "TC3"+secretKey) secretService := hmacsha256(service, secretDate) secretSigning := hmacsha256("tc3_request", secretService) signature := hex.EncodeToString([]byte(hmacsha256(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) fmt.Println(authorization) curl := fmt.Sprintf(`curl -X POST https://%s\ -H "Authorization: %s"\ -H "Content-Type: application/json; charset=utf-8"\ -H "Host: %s" -H "X-TC-Action: %s"\ -H "X-TC-Timestamp: %d"\ -H "X-TC-Version: %s"\ -H "X-TC-Region: %s"\ -d '%s'`, host, authorization, host, action, timestamp, version, region, payload) fmt.Println(curl) } ``` #### PHP ``` =2.3.0 require 'digest' require 'json' require 'time' require 'openssl' # Key Parameters secret_id = 'AKIDz8krbsJ5yKBZQpn74WFkmLPx3*******' secret_key = 'Gu5t9xGARNpq86cd98joQYCN3*******' service = 'cvm' host = 'cvm.tencentcloudapi.com' endpoint = 'https://' + host region = 'ap-guangzhou' action = 'DescribeInstances' version = '2017-03-12' algorithm = 'TC3-HMAC-SHA256' # timestamp = Time.now.to_i timestamp = 1551113065 date = Time.at(timestamp).utc.strftime('%Y-%m-%d') # ************* Step 1: Concatenate the CanonicalRequest string ************* http_request_method = 'POST' canonical_uri = '/' canonical_querystring = '' canonical_headers = "content-type:application/json; charset=utf-8\nhost:#{host}\n" signed_headers = 'content-type;host' # params = { 'Limit' => 1, 'Filters' => [{ 'Name' => 'instance-name', 'Values' => ['unnamed'] }] } # payload = JSON.generate(params, { 'ascii_only' => true, 'space' => ' ' }) # json will generate in random order, to get specified result in example, we hard-code it here. payload = '{"Limit": 1, "Filters": [{"Values": ["unnamed"], "Name": "instance-name"}]}' hashed_request_payload = Digest::SHA256.hexdigest(payload) canonical_request = [ http_request_method, canonical_uri, canonical_querystring, canonical_headers, signed_headers, hashed_request_payload, ].join("\n") puts canonical_request # ************* Step 2: Concatenate the string to sign ************* credential_scope = date + '/' + service + '/' + 'tc3_request' hashed_request_payload = Digest::SHA256.hexdigest(canonical_request) string_to_sign = [ algorithm, timestamp.to_s, credential_scope, hashed_request_payload, ].join("\n") puts string_to_sign # ************* Step 3: Calculate the Signature ************* digest = OpenSSL::Digest.new('sha256') secret_date = OpenSSL::HMAC.digest(digest, 'TC3' + secret_key, date) secret_service = OpenSSL::HMAC.digest(digest, secret_date, service) secret_signing = OpenSSL::HMAC.digest(digest, secret_service, 'tc3_request') signature = OpenSSL::HMAC.hexdigest(digest, secret_signing, string_to_sign) puts signature # ************* Step 4: Concatenate the Authorization ************* authorization = "#{algorithm} Credential=#{secret_id}/#{credential_scope}, SignedHeaders=#{signed_headers}, Signature=#{signature}" puts authorization puts 'curl -X POST ' + endpoint \ + ' -H "Authorization: ' + authorization + '"' \ + ' -H "Content-Type: application/json; charset=utf-8"' \ + ' -H "Host: ' + host + '"' \ + ' -H "X-TC-Action: ' + action + '"' \ + ' -H "X-TC-Timestamp: ' + timestamp.to_s + '"' \ + ' -H "X-TC-Version: ' + version + '"' \ + ' -H "X-TC-Region: ' + region + '"' \ + " -d '" + payload + "'" ``` #### DotNet ``` using System; using System.Collections.Generic; using System.Security.Cryptography; using System.Text; public class Application { public static string SHA256Hex(string s) { using (SHA256 algo = SHA256.Create()) { byte[] hashbytes = algo.ComputeHash(Encoding.UTF8.GetBytes(s)); StringBuilder builder = new StringBuilder(); for (int i = 0; i < hashbytes.Length; ++i) { builder.Append(hashbytes[i].ToString("x2")); } return builder.ToString(); } } public static byte[] HmacSHA256(byte[] key, byte[] msg) { using (HMACSHA256 mac = new HMACSHA256(key)) { return mac.ComputeHash(msg); } } public static Dictionary BuildHeaders(string secretid, string secretkey, string service, string endpoint, string region, string action, string version, DateTime date, string requestPayload) { string datestr = date.ToString("yyyy-MM-dd"); DateTime startTime = new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc); long requestTimestamp = (long)Math.Round((date - startTime).TotalMilliseconds, MidpointRounding.AwayFromZero) / 1000; // ************* Step 1: Concatenate the CanonicalRequest string ************* string algorithm = "TC3-HMAC-SHA256"; string httpRequestMethod = "POST"; string canonicalUri = "/"; string canonicalQueryString = ""; string contentType = "application/json"; string canonicalHeaders = "content-type:" + contentType + "; charset=utf-8\n" + "host:" + endpoint + "\n"; string signedHeaders = "content-type;host"; string hashedRequestPayload = SHA256Hex(requestPayload); string canonicalRequest = httpRequestMethod + "\n" + canonicalUri + "\n" + canonicalQueryString + "\n" + canonicalHeaders + "\n" + signedHeaders + "\n" + hashedRequestPayload; Console.WriteLine(canonicalRequest); Console.WriteLine("----------------------------------"); // ************ Step 2: Concatenate the string to sign ************* string credentialScope = datestr + "/" + service + "/" + "tc3_request"; string hashedCanonicalRequest = SHA256Hex(canonicalRequest); string stringToSign = algorithm + "\n" + requestTimestamp.ToString() + "\n" + credentialScope + "\n" + hashedCanonicalRequest; Console.WriteLine(stringToSign); Console.WriteLine("----------------------------------"); // ************* Step 3: Calculate the signature ************* byte[] tc3SecretKey = Encoding.UTF8.GetBytes("TC3" + secretkey); byte[] secretDate = HmacSHA256(tc3SecretKey, Encoding.UTF8.GetBytes(datestr)); byte[] secretService = HmacSHA256(secretDate, Encoding.UTF8.GetBytes(service)); byte[] secretSigning = HmacSHA256(secretService, Encoding.UTF8.GetBytes("tc3_request")); byte[] signatureBytes = HmacSHA256(secretSigning, Encoding.UTF8.GetBytes(stringToSign)); string signature = BitConverter.ToString(signatureBytes).Replace("-", "").ToLower(); Console.WriteLine(signature); Console.WriteLine("----------------------------------"); // ************* Step 4: Concatenate the Authorization ************* string authorization = algorithm + " " + "Credential=" + secretid + "/" + credentialScope + ", " + "SignedHeaders=" + signedHeaders + ", " + "Signature=" + signature; Console.WriteLine(authorization); Console.WriteLine("----------------------------------"); Dictionary headers = new Dictionary(); headers.Add("Authorization", authorization); headers.Add("Host", endpoint); headers.Add("Content-Type", contentType + "; charset=utf-8"); headers.Add("X-TC-Timestamp", requestTimestamp.ToString()); headers.Add("X-TC-Version", version); headers.Add("X-TC-Action", action); headers.Add("X-TC-Region", region); return headers; } public static void Main(string[] args) { // SecretID and SecretKey string SECRET_ID = "AKIDz8krbsJ5yKBZQpn74WFkmLPx3*******"; string SECRET_KEY = "Gu5t9xGARNpq86cd98joQYCN3*******"; string service = "cvm"; string endpoint = "cvm.tencentcloudapi.com"; string region = "ap-guangzhou"; string action = "DescribeInstances"; string version = "2017-03-12"; // The timestamp `2019-02-26 00:44:25` used here is only for reference. In a project, use the following parameter: // DateTime date = DateTime.UtcNow; // Enter the correct time zone. We recommend using UTC timestamp to avoid errors. DateTime date = new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc).AddSeconds(1551113065); string requestPayload = "{\"Limit\": 1, \"Filters\": [{\"Values\": [\"\\u672a\\u547d\\u540d\"], \"Name\": \"instance-name\"}]}"; Dictionary headers = BuildHeaders(SECRET_ID, SECRET_KEY, service , endpoint, region, action, version, date, requestPayload); Console.WriteLine("POST https://cvm.tencentcloudapi.com"); foreach (KeyValuePair kv in headers) { Console.WriteLine(kv.Key + ": " + kv.Value); } Console.WriteLine(); Console.WriteLine(requestPayload); } } ``` #### NodeJS ``` const crypto = require('crypto'); function sha256(message, secret = '', encoding) { const hmac = crypto.createHmac('sha256', secret) return hmac.update(message).digest(encoding) } function getHash(message, encoding = 'hex') { const hash = crypto.createHash('sha256') return hash.update(message).digest(encoding) } function getDate(timestamp) { const date = new Date(timestamp * 1000) const year = date.getUTCFullYear() const month = ('0' + (date.getUTCMonth() + 1)).slice(-2) const day = ('0' + date.getUTCDate()).slice(-2) return `${year}-${month}-${day}` } function main(){ const SECRET_ID = "AKIDz8krbsJ5yKBZQpn74WFkmLPx3*******" const SECRET_KEY = "Gu5t9xGARNpq86cd98joQYCN3*******" const endpoint = "cvm.tencentcloudapi.com" const service = "cvm" const region = "ap-guangzhou" const action = "DescribeInstances" const version = "2017-03-12" //const timestamp = getTime() const timestamp = 1551113065 const date = getDate(timestamp) // ************* Step 1: Concatenate the CanonicalRequest string ************* const signedHeaders = "content-type;host" const payload = "{\"Limit\": 1, \"Filters\": [{\"Values\": [\"unnamed\"], \"Name\": \"instance-name\"}]}" const hashedRequestPayload = getHash(payload); const httpRequestMethod = "POST" const canonicalUri = "/" const canonicalQueryString = "" const canonicalHeaders = "content-type:application/json; charset=utf-8\n" + "host:" + endpoint + "\n" const canonicalRequest = httpRequestMethod + "\n" + canonicalUri + "\n" + canonicalQueryString + "\n" + canonicalHeaders + "\n" + signedHeaders + "\n" + hashedRequestPayload console.log(canonicalRequest) console.log("----------------------------") // ************* Step 2: Concatenate the string to sign ************* const algorithm = "TC3-HMAC-SHA256" const hashedCanonicalRequest = getHash(canonicalRequest); const credentialScope = date + "/" + service + "/" + "tc3_request" const stringToSign = algorithm + "\n" + timestamp + "\n" + credentialScope + "\n" + hashedCanonicalRequest console.log(stringToSign) console.log("----------------------------") // ************* Step 3: Calculate the signature ************* const kDate = sha256(date, 'TC3' + SECRET_KEY) const kService = sha256(service, kDate) const kSigning = sha256('tc3_request', kService) const signature = sha256(stringToSign, kSigning, 'hex') console.log(signature) console.log("----------------------------") // ************* Step 4: Concatenate the Authorization ************* const authorization = algorithm + " " + "Credential=" + SECRET_ID + "/" + credentialScope + ", " + "SignedHeaders=" + signedHeaders + ", " + "Signature=" + signature console.log(authorization) console.log("----------------------------") const Call_Information = 'curl -X POST ' + "https://" + endpoint + ' -H "Authorization: ' + authorization + '"' + ' -H "Content-Type: application/json; charset=utf-8"' + ' -H "Host: ' + endpoint + '"' + ' -H "X-TC-Action: ' + action + '"' + ' -H "X-TC-Timestamp: ' + timestamp.toString() + '"' + ' -H "X-TC-Version: ' + version + '"' + ' -H "X-TC-Region: ' + region + '"' + " -d '" + payload + "'" console.log(Call_Information) } main() ``` #### C++ ``` #include #include #include #include #include #include #include #include using namespace std; string get_data(int64_t ×tamp) { string utcDate; char buff[20] = {0}; // time_t timenow; struct tm sttime; sttime = *gmtime(×tamp); strftime(buff, sizeof(buff), "%Y-%m-%d", &sttime); utcDate = string(buff); return utcDate; } string int2str(int64_t n) { std::stringstream ss; ss << n; return ss.str(); } string sha256Hex(const string &str) { char buf[3]; unsigned char hash[SHA256_DIGEST_LENGTH]; SHA256_CTX sha256; SHA256_Init(&sha256); SHA256_Update(&sha256, str.c_str(), str.size()); SHA256_Final(hash, &sha256); std::string NewString = ""; for(int i = 0; i < SHA256_DIGEST_LENGTH; i++) { snprintf(buf, sizeof(buf), "%02x", hash[i]); NewString = NewString + buf; } return NewString; } string HmacSha256(const string &key, const string &input) { unsigned char hash[32]; HMAC_CTX *h; #if OPENSSL_VERSION_NUMBER < 0x10100000L HMAC_CTX hmac; HMAC_CTX_init(&hmac); h = &hmac; #else h = HMAC_CTX_new(); #endif HMAC_Init_ex(h, &key[0], key.length(), EVP_sha256(), NULL); HMAC_Update(h, ( unsigned char* )&input[0], input.length()); unsigned int len = 32; HMAC_Final(h, hash, &len); #if OPENSSL_VERSION_NUMBER < 0x10100000L HMAC_CTX_cleanup(h); #else HMAC_CTX_free(h); #endif std::stringstream ss; ss << std::setfill('0'); for (int i = 0; i < len; i++) { ss << hash[i]; } return (ss.str()); } string HexEncode(const string &input) { static const char* const lut = "0123456789abcdef"; size_t len = input.length(); string output; output.reserve(2 * len); for (size_t i = 0; i < len; ++i) { const unsigned char c = input[i]; output.push_back(lut[c >> 4]); output.push_back(lut[c & 15]); } return output; } int main() { string SECRET_ID = "AKIDz8krbsJ5yKBZQpn74WFkmLPx3*******"; string SECRET_KEY = "Gu5t9xGARNpq86cd98joQYCN3*******"; string service = "cvm"; string host = "cvm.tencentcloudapi.com"; string region = "ap-guangzhou"; string action = "DescribeInstances"; string version = "2017-03-12"; int64_t timestamp = 1551113065; string date = get_data(timestamp); // ************* Step 1: Concatenate the CanonicalRequest string ************* string httpRequestMethod = "POST"; string canonicalUri = "/"; string canonicalQueryString = ""; string canonicalHeaders = "content-type:application/json; charset=utf-8\nhost:" + host + "\n"; string signedHeaders = "content-type;host"; string payload = "{\"Limit\": 1, \"Filters\": [{\"Values\": [\"unnamed\"], \"Name\": \"instance-name\"}]}"; string hashedRequestPayload = sha256Hex(payload); string canonicalRequest = httpRequestMethod + "\n" + canonicalUri + "\n" + canonicalQueryString + "\n" + canonicalHeaders + "\n" + signedHeaders + "\n" + hashedRequestPayload; cout << canonicalRequest << endl; cout << "-----------------------" << endl; // ************* Step 2: Concatenate the string to sign ************* string algorithm = "TC3-HMAC-SHA256"; string RequestTimestamp = int2str(timestamp); string credentialScope = date + "/" + service + "/" + "tc3_request"; string hashedCanonicalRequest = sha256Hex(canonicalRequest); string stringToSign = algorithm + "\n" + RequestTimestamp + "\n" + credentialScope + "\n" + hashedCanonicalRequest; cout << stringToSign << endl; cout << "-----------------------" << endl; // ************* Step 3: Calculate the signature *************** string kKey = "TC3" + SECRET_KEY; string kDate = HmacSha256(kKey, date); string kService = HmacSha256(kDate, service); string kSigning = HmacSha256(kService, "tc3_request"); string signature = HexEncode(HmacSha256(kSigning, stringToSign)); cout << signature << endl; cout << "-----------------------" << endl; // ************* Step 4: Concatenate the Authorization ************* string authorization = algorithm + " " + "Credential=" + SECRET_ID + "/" + credentialScope + ", " + "SignedHeaders=" + signedHeaders + ", " + "Signature=" + signature; cout << authorization << endl; cout << "------------------------" << endl; string headers = "curl -X POST https://" + host + "\n" + " -H \"Authorization: " + authorization + "\n" + " -H \"Content-Type: application/json; charset=utf-8\"" + "\n" + " -H \"Host: " + host + "\n" + " -H \"X-TC-Action: " + action + "\n" + " -H \"X-TC-Timestamp: " + RequestTimestamp + "\n" + " -H \"X-TC-Version: " + version + "\n" + " -H \"X-TC-Region: " + region + "\n" + " -d '" + payload; cout << headers << endl; return 0; }; ``` ## Signature Failure The following situational error codes for signature failure may occur. Please resolve the errors accordingly. | Error Code | Description | |----------|---------| | AuthFailure.SignatureExpire | Signature expired. Timestamp and server time cannot differ by more than five minutes. | | AuthFailure.SecretIdNotFound | The key does not exist. Please go to the console to check whether it is disabled or you copied fewer or more characters. | | AuthFailure.SignatureFailure | Signature error. It is possible that the signature was calculated incorrectly, the signature does not match the content actually sent, or the SecretKey is incorrect. | | AuthFailure.TokenFailure | Temporary certificate token error. | | AuthFailure.InvalidSecretId | Invalid key (not a TencentCloud API key type). |
Contact Us

Contact our sales team or business advisors to help your business.

Technical Support

Open a ticket if you're looking for further assistance. Our Ticket is 7x24 avaliable.

7x24 Phone Support