Alibaba Cloud SDK:RPC スタイル API のリクエストボディと署名メカニズム V2

固定パラメーターの例

Java の例

Java の例を実行するには、次の Maven 依存関係を pom.xml ファイルに追加します。

<dependency>
    <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpclient</artifactId>
    <version>4.5.13</version>
</dependency>

import org.apache.http.client.methods.*;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.entity.ByteArrayEntity;
import org.apache.http.entity.ContentType;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URISyntaxException;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.text.SimpleDateFormat;
import java.util.*;

public class Demo {
    private static final String ACCESS_KEY_ID = System.getenv("ALIBABA_CLOUD_ACCESS_KEY_ID");
    private static final String ACCESS_KEY_SECRET = System.getenv("ALIBABA_CLOUD_ACCESS_KEY_SECRET");

    public static class SignatureRequest {
        public final String httpMethod;
        public final String host;
        public final String action;
        public final String version;
        public final String canonicalUri = "/";
        public TreeMap<String, Object> headers = new TreeMap<>();
        public TreeMap<String, Object> queryParams = new TreeMap<>();
        public TreeMap<String, Object> body = new TreeMap<>();
        public TreeMap<String, Object> allParams = new TreeMap<>();
        public byte[] bodyByte;

        public SignatureRequest(String httpMethod, String host, String action, String version) {
            this.httpMethod = httpMethod;
            this.host = host;
            this.action = action;
            this.version = version;
            setExtendedHeaders();
        }

        public void setExtendedHeaders() {
            headers.put("AccessKeyId", ACCESS_KEY_ID);
            headers.put("Format", "JSON");
            headers.put("SignatureMethod", "HMAC-SHA1");
            headers.put("SignatureVersion", "1.0");
            headers.put("SignatureNonce", UUID.randomUUID().toString());
            SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'")
            format.setTimeZone(new SimpleTimeZone(0, "GMT"));
            headers.put("Timestamp", format.format(new Date()));
            headers.put("Action", action);
            headers.put("Version", version);
        }

        public void getAllParams() {
            allParams.putAll(headers);
            if (!queryParams.isEmpty()) {
                allParams.putAll(queryParams);
            }
            if (!body.isEmpty()) {
                allParams.putAll(body);
            }
        }
    }

    public static void main(String[] args) throws IOException {
        // 例 1: ボディなしで API リクエストを送信します。
        String httpMethod = "POST";
        String endpoint = "dysmsapi.aliyuncs.com";
        String action = "SendSms";
        String version = "2017-05-25";
        SignatureRequest signatureRequest = new SignatureRequest(httpMethod, endpoint, action, version);
        signatureRequest.queryParams.put("PhoneNumbers", "123XXXXXXXX");
        signatureRequest.queryParams.put("SignName", "XXXXXXX");
        signatureRequest.queryParams.put("TemplateCode", "XXXXXXX");
        signatureRequest.queryParams.put("TemplateParam", "XXXXXXX");

        /*// 例 2: ボディ付きで API リクエストを送信します。
        String httpMethod = "POST";
        String endpoint = "mt.aliyuncs.com";
        String action = "TranslateGeneral";
        String version = "2018-10-12";
        SignatureRequest signatureRequest = new SignatureRequest(httpMethod, endpoint, action, version);
        TreeMap<String, Object> body = new TreeMap<>();
        body.put("FormatType", "text");
        body.put("SourceLanguage", "zh");
        body.put("TargetLanguage", "en");
        body.put("SourceText", "Hello");
        body.put("Scene", "general");
        signatureRequest.body = body;
        String formDataToString = formDataToString(body);
        signatureRequest.bodyByte = formDataToString.getBytes(StandardCharsets.UTF_8);
        signatureRequest.headers.put("content-type", "application/x-www-form-urlencoded");*/

        /*// 例 3: ボディがバイナリファイルの API リクエストを送信します。
        String httpMethod = "POST";
        String endpoint = "ocr-api.cn-hangzhou.aliyuncs.com";
        String action = "RecognizeGeneral";
        String version = "2021-07-07";
        SignatureRequest signatureRequest = new SignatureRequest(httpMethod, endpoint, action, version);
        signatureRequest.bodyByte = Files.readAllBytes(Paths.get("D:\\test.png"));
        signatureRequest.headers.put("content-type", "application/octet-stream");*/

        // 署名文字列を計算します。
        calculateSignature(signatureRequest);

        // リクエストを送信して、署名文字列が有効かどうかをテストします。
        callApi(signatureRequest);
    }

    private static void calculateSignature(SignatureRequest signatureRequest) {
        // ヘッダー、queryParam、およびボディを、正規化されたクエリ文字列の作成に使用されるマップにマージします。
        signatureRequest.getAllParams();

        // 正規化されたクエリ文字列を作成します。
        StringBuilder canonicalQueryString = new StringBuilder();
        signatureRequest.allParams.entrySet().stream().map(entry -> percentEncode(entry.getKey()) + "="
                + percentEncode(String.valueOf(entry.getValue()))).forEachOrdered(queryPart -> {
            if (canonicalQueryString.length() > 0) {
                canonicalQueryString.append("&");
            }
            canonicalQueryString.append(queryPart);
        });
        System.out.println("canonicalQueryString:" + canonicalQueryString);

        // 署名対象文字列を作成します。
        String stringToSign = signatureRequest.httpMethod + "&" + percentEncode(signatureRequest.canonicalUri) + "&" + percentEncode(String.valueOf(canonicalQueryString));
        System.out.println("stringToSign:" + stringToSign);
        // 署名文字列を計算します。
        String signature = generateSignature(ACCESS_KEY_SECRET, stringToSign);
        System.out.println("signature:" + signature);
        signatureRequest.allParams.put("Signature", signature);
    }

    private static void callApi(SignatureRequest signatureRequest) {
        try {
            String url = String.format("https://%s/", signatureRequest.host);
            URIBuilder uriBuilder = new URIBuilder(url);
            for (Map.Entry<String, Object> entry : signatureRequest.allParams.entrySet()) {
                uriBuilder.addParameter(entry.getKey(), String.valueOf(entry.getValue()));
            }
            HttpUriRequest httpRequest;
            switch (signatureRequest.httpMethod) {
                case "GET":
                    httpRequest = new HttpGet(uriBuilder.build());
                    break;
                case "POST":
                    HttpPost httpPost = new HttpPost(uriBuilder.build());
                    if (signatureRequest.bodyByte != null) {
                        httpPost.setEntity(new ByteArrayEntity(signatureRequest.bodyByte, ContentType.create((String) signatureRequest.headers.get("content-type"))));
                    }
                    httpRequest = httpPost;
                    break;
                default:
                    System.out.println("Unsupported HTTP method: " + signatureRequest.httpMethod);
                    throw new IllegalArgumentException("Unsupported HTTP method");
            }
            try (CloseableHttpClient httpClient = HttpClients.createDefault(); CloseableHttpResponse response = httpClient.execute(httpRequest)) {
                String result = EntityUtils.toString(response.getEntity(), StandardCharsets.UTF_8);
                System.out.println(result);
            } catch (IOException e) {
                System.out.println("Failed to send request");
                throw new RuntimeException(e);
            }
        } catch (URISyntaxException e) {
            throw new RuntimeException(e);
        }
    }

    private static String formDataToString(Map<String, Object> formData) {
        Map<String, Object> tileMap = new HashMap<>();
        processObject(tileMap, "", formData);
        StringBuilder result = new StringBuilder();
        boolean first = true;
        String symbol = "&";
        for (Map.Entry<String, Object> entry : tileMap.entrySet()) {
            String value = String.valueOf(entry.getValue());
            if (value != null && !value.isEmpty()) {
                if (first) {
                    first = false;
                } else {
                    result.append(symbol);
                }
                result.append(percentEncode(entry.getKey()));
                result.append("=");
                result.append(percentEncode(value));
            }
        }

        return result.toString();
    }

    private static void processObject(Map<String, Object> map, String key, Object value) {
        // null 値に対しては、これ以上の処理は必要ありません。
        if (value == null) {
            return;
        }
        if (key == null) {
            key = "";
        }
        // 値が List 型の場合は、リストを走査し、各要素に対して再帰を実行します。
        if (value instanceof List<?>) {
            List<?> list = (List<?>) value;
            for (int i = 0; i < list.size(); ++i) {
                processObject(map, key + "." + (i + 1), list.get(i));
            }
        } else if (value instanceof Map<?, ?>) {
            // 値が Map 型の場合は、マップを走査し、各キーと値のペアに対して再帰を実行します。
            Map<?, ?> subMap = (Map<?, ?>) value;
            for (Map.Entry<?, ?> entry : subMap.entrySet()) {
                processObject(map, key + "." + entry.getKey().toString(), entry.getValue());
            }
        } else {
            // キーがピリオド (.) で始まる場合は、キーの連続性を維持するためにピリオド (.) を削除します。
            if (key.startsWith(".")) {
                key = key.substring(1);
            }
            // 値が byte[] 形式の場合は、値を UTF-8 でエンコードされた文字列に変換します。
            if (value instanceof byte[]) {
                map.put(key, new String((byte[]) value, StandardCharsets.UTF_8));
            } else {
                // 他の型の値を文字列に変換します。
                map.put(key, String.valueOf(value));
            }
        }
    }

    public static String generateSignature(String accessSecret, String stringToSign) {
        try {
            // HMAC-SHA1 キーを作成します。
            SecretKeySpec signingKey = new SecretKeySpec((accessSecret + "&").getBytes(StandardCharsets.UTF_8), "HmacSHA1");
            // Mac インスタンスを作成して初期化します
            Mac mac = Mac.getInstance("HmacSHA1");
            mac.init(signingKey);
            // HMAC-SHA1 アルゴリズムを使用して署名文字列を計算します。
            byte[] rawHmac = mac.doFinal(stringToSign.getBytes(StandardCharsets.UTF_8));
            return Base64.getEncoder().encodeToString(rawHmac);
        } catch (NoSuchAlgorithmException | InvalidKeyException e) {
            System.out.println("Failed to generate HMAC-SHA1 signature");
            throw new RuntimeException(e);
        }
    }

    public static String percentEncode(String str) {
        if (str == null) {
            throw new IllegalArgumentException("The specified string cannot be null.");
        }
        try {
            return URLEncoder.encode(str, StandardCharsets.UTF_8.name()).replace("+", "%20").replace("*", "%2A").replace("%7E", "~");
        } catch (UnsupportedEncodingException e) {
            throw new RuntimeException("UTF-8 encoding is not supported.", e);
        }
    }
}

Python の例

サンプルコードを実行するには、requests ライブラリをインストールします。

pip install requests

import base64
import hashlib
import hmac
import os
import urllib.parse
import uuid
from collections import OrderedDict
from datetime import datetime, UTC
from typing import Dict, Any

import requests

# 環境変数から AccessKey ペアを取得します。
ACCESS_KEY_ID = os.environ.get("ALIBABA_CLOUD_ACCESS_KEY_ID")
ACCESS_KEY_SECRET = os.environ.get("ALIBABA_CLOUD_ACCESS_KEY_SECRET")


class SignatureRequest:
    """
    リクエストに署名するためのクラス。このクラスは、RPC API リクエストの構築と管理に使用されます。
    """

    def __init__(self, http_method: str, host: str, action: str, version: str):
        """
        署名リクエストオブジェクトを初期化します。

        引数:
            http_method: GET や POST などの HTTP リクエストメソッド。
            host: API サービスのドメイン名。
            action: API アクションの名前。
            version: API のバージョン番号。
        """
        self.http_method = http_method.upper()
        self.host = host
        self.action = action
        self.version = version
        self.canonical_uri = "/"  # RPC API はルートパスを使用します。
        self.headers: Dict[str, Any] = OrderedDict()  # リクエストヘッダーパラメーター。
        self.query_params: Dict[str, Any] = OrderedDict()  # クエリパラメーター。
        self.body: Dict[str, Any] = OrderedDict()  # リクエストボディパラメーター。
        self.body_byte: bytes = b""  # バイト単位のリクエストボディ。
        self.all_params: Dict[str, Any] = OrderedDict()  # すべてのパラメーターのコレクション。
        self.set_headers()

    def set_headers(self) -> None:
        """
        RPC リクエストに必要な基本的なリクエストヘッダーパラメーターを設定します。
        """
        self.headers["AccessKeyId"] = ACCESS_KEY_ID  # AccessKey ID。
        self.headers["Format"] = "JSON"  # 応答のフォーマット。
        self.headers["SignatureMethod"] = "HMAC-SHA1"  # 署名アルゴリズム。
        self.headers["SignatureVersion"] = "1.0"  # 署名バージョン。
        self.headers["SignatureNonce"] = "{" + str(uuid.uuid4()) + "}"  # リプレイ防止用のランダムな文字列。
        self.headers["Timestamp"] = datetime.now(UTC).strftime("%Y-%m-%dT%H:%M:%SZ")  # タイムスタンプ。
        self.headers["Action"] = self.action  # API の名前。
        self.headers["Version"] = self.version  # API のバージョン番号。

    def set_content_type(self, content_type):
        self.headers["Content-Type"] = content_type

    def get_all_params(self) -> None:
        """
        すべてのリクエストパラメーターを収集してソートします。
        """
        # すべてのパラメーターをマージします: ヘッダー、query_params、およびボディ。
        self.all_params.update(self.headers)
        if self.query_params:
            self.all_params.update(self.query_params)
        if self.body:
            self.body_byte = form_data_to_string(body).encode("utf-8")
            self.all_params.update(self.body)

        # パラメーターを名前の ASCII 順にソートします。
        self.all_params = OrderedDict(sorted(self.all_params.items()))


def calculate_signature(signature_request: SignatureRequest) -> None:
    """
    RPC リクエストの署名を計算します。

    引数:
        signature_request: 署名リクエストオブジェクト。
    """
    signature_request.get_all_params()  # すべてのパラメーターを収集してソートします。

    # 正規化されたクエリ文字列を作成します。
    canonical_query_string = "&".join(
        f"{percent_encode(k)}={percent_encode(v)}"
        for k, v in signature_request.all_params.items()
    )
    print(f"canonicalQueryString:{canonical_query_string}")

    # 署名対象文字列を作成します: HTTP メソッド + 正規 URI + 正規化されたクエリ文字列。
    string_to_sign = (
        f"{signature_request.http_method}&"
        f"{percent_encode(signature_request.canonical_uri)}&"
        f"{percent_encode(canonical_query_string)}"
    )
    print(f"stringToSign:{string_to_sign}")

    # 署名を生成します。
    signature = generate_signature(ACCESS_KEY_SECRET, string_to_sign)
    signature_request.all_params["Signature"] = signature  # パラメーターに署名を追加します。


def form_data_to_string(form_data: Dict[str, Any]) -> str:
    """
    フォームデータを URL エンコードされた文字列に変換します。

    引数:
        form_data: フォームデータの辞書。

    戻り値:
        URL エンコードされた文字列。
    """
    tile_map: Dict[str, Any] = {}

    def process_object(key: str, value: Any) -> None:
        """
        オブジェクトを再帰的に処理して、ネストされた構造をフラット化します。

        引数:
            key: パラメーターキー。
            value: パラメーター値。
        """
        if value is None:
            return
        if isinstance(value, list):
            # リスト型のパラメーターを処理します。
            for i, item in enumerate(value):
                process_object(f"{key}.{i + 1}", item)
        elif isinstance(value, dict):
            # 辞書型のパラメーターを処理します。
            for k, v in value.items():
                process_object(f"{key}.{k}", v)
        else:
            # 先頭のピリオドを削除します。
            clean_key = key[1:] if key.startswith(".") else key
            # バイトデータと通常のデータを処理します。
            tile_map[clean_key] = value.decode("utf-8") if isinstance(value, bytes) else str(value)

    # すべてのフォームデータを処理します。
    for k, v in form_data.items():
        process_object(k, v)

    # URL エンコードして項目を連結します。
    encoded_items = [
        f"{percent_encode(k)}={percent_encode(v)}"
        for k, v in tile_map.items() if v
    ]

    return "&".join(encoded_items)


def generate_signature(access_secret: str, string_to_sign: str) -> str:
    """
    HMAC-SHA1 アルゴリズムを使用して署名を生成します。

    引数:
        access_secret: AccessKey Secret。
        string_to_sign: 署名対象の文字列。

    戻り値:
        Base64 エンコードされた署名。
    """
    try:
        # 署名キーは、AccessKey Secret にアンパサンド (&) を追加したものです。
        signing_key = (access_secret + "&").encode("utf-8")
        # HMAC-SHA1 アルゴリズムを使用して署名を計算します。
        signature = hmac.new(signing_key, string_to_sign.encode("utf-8"), hashlib.sha1).digest()
        # 署名を Base64 エンコードします。
        return base64.b64encode(signature).decode("utf-8")
    except Exception as e:
        print(f"Failed to generate HMAC-SHA1 signature: {e}")
        raise


def percent_encode(s: str) -> str:
    """
    RFC 3986 に基づいて文字列をパーセントエンコードします。

    引数:
        s: エンコードする文字列。

    戻り値:
        エンコードされた文字列。
    """
    if s is None:
        raise ValueError("Input string cannot be None")
    # UTF-8 エンコーディング後に文字列を URL エンコードします。チルダ (~) 文字はエンコードされません。
    encoded = urllib.parse.quote(s.encode("utf-8"), safe=b"~")
    # 特殊文字のエンコーディングを置き換えます。
    return encoded.replace("+", "%20").replace("*", "%2A")


def call_api(signature_request: SignatureRequest) -> None:
    """
    API リクエストを開始する方法の例。
    """
    url = f"https://{signature_request.host}/"

    # リクエストパラメーターを作成します。
    params = {k: str(v) for k, v in signature_request.all_params.items()}

    # リクエストパラメーターを準備します。
    request_kwargs = {
        "params": params
    }

    # リクエストボディデータが存在する場合は追加します。
    if signature_request.body_byte:
        request_kwargs["data"] = signature_request.body_byte
        headers = {"Content-Type": signature_request.headers.get("Content-Type")}
        request_kwargs["headers"] = headers

    try:
        # requests.request を使用して、さまざまな HTTP メソッドを処理します。
        response = requests.request(
            method=signature_request.http_method,
            url=url,
            **request_kwargs
        )

        print(f"Request URL: {response.url}")
        print(f"Response: {response.text}")

    except requests.RequestException as e:
        print(f"HTTP request failed: {e}")
        raise
    except Exception as e:
        print(f"Failed to send request: {e}")
        raise


if __name__ == "__main__":
    # 例 1: ボディのないリクエスト。Content-Type ヘッダーは任意です。このヘッダーを指定する場合は、application/json に設定します。
    signature_request = SignatureRequest(
        http_method="POST",
        host="dysmsapi.aliyuncs.com",
        action="SendSms",
        version="2017-05-25"
    )
    # query_params を使用してクエリパラメーターを設定します。
    signature_request.query_params["SignName"] = "******"
    signature_request.query_params["TemplateCode"] = "SMS_******"
    signature_request.query_params["PhoneNumbers"] = "******"
    signature_request.query_params["TemplateParam"] = "{'code':'1234'}"

    # 例 2: ボディのあるリクエスト。Content-Type ヘッダーは application/x-www-form-urlencoded に設定する必要があります。application/json には設定しないでください。
    """
    signature_request = SignatureRequest(
        http_method="POST",
        host="mt.aliyuncs.com",
        action="TranslateGeneral",
        version="2018-10-12"
    )
    body = {
        "FormatType": "text",
        "SourceLanguage": "zh",
        "TargetLanguage": "en",
        "SourceText": "Hello",
        "Scene": "general"
    }
    signature_request.body = body
    signature_request.set_content_type("application/x-www-form-urlencoded")
    """

    # 例 3: バイナリファイルストリームをアップロードします。Content-Type ヘッダーは application/octet-stream に設定する必要があります。
    """
    signature_request = SignatureRequest(
        http_method="POST",
        host="ocr-api.cn-hangzhou.aliyuncs.com",
        action="RecognizeGeneral",
        version="2021-07-07"
    )
    with open("D:\\test.jpeg", "rb") as f:
        signature_request.body_byte = f.read()
    signature_request.set_content_type("application/octet-stream")
    """

    # 署名を計算します。
    calculate_signature(signature_request)

    # サンプルリクエストを開始します。
    call_api(signature_request)