Simple Message Queue (formerly MNS):Request protocol

import base64
import hashlib
import hmac
import os
from datetime import datetime, timezone


def sign_request(access_key_id, access_key_secret, method, resource,
                 content_type="", content_md5="", mns_headers=None):
    """Generate the Authorization header for an SMQ request."""
    date = datetime.now(timezone.utc).strftime("%a, %d %b %Y %H:%M:%S GMT")

    # Build CanonicalizedMNSHeaders
    canonicalized_headers = ""
    if mns_headers:
        for key in sorted(mns_headers.keys()):
            canonicalized_headers += f"{key.lower()}:{mns_headers[key]}\n"

    string_to_sign = (
        f"{method}\n{content_md5}\n{content_type}\n{date}\n"
        f"{canonicalized_headers}{resource}"
    )

    signature = base64.b64encode(
        hmac.new(
            access_key_secret.encode("utf-8"),
            string_to_sign.encode("utf-8"),
            hashlib.sha1,
        ).digest()
    ).decode("utf-8")

    return {
        "Authorization": f"MNS {access_key_id}:{signature}",
        "Date": date,
        "x-mns-version": "2015-06-06",
    }


# Usage
headers = sign_request(
    access_key_id=os.environ["ALIBABA_CLOUD_ACCESS_KEY_ID"],
    access_key_secret=os.environ["ALIBABA_CLOUD_ACCESS_KEY_SECRET"],
    method="PUT",
    resource="/queues/examplequeue?metaOverride=true",
    content_type="text/xml",
    mns_headers={"x-mns-version": "2015-06-06"},
)

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.time.ZoneOffset;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;
import java.util.*;

public class MnsSignature {

    public static Map<String, String> signRequest(
            String accessKeyId, String accessKeySecret,
            String method, String resource,
            String contentType, String contentMd5,
            Map<String, String> mnsHeaders) throws Exception {

        String date = DateTimeFormatter.RFC_1123_DATE_TIME
                .format(ZonedDateTime.now(ZoneOffset.UTC));

        // Build CanonicalizedMNSHeaders
        StringBuilder canonicalizedHeaders = new StringBuilder();
        if (mnsHeaders != null) {
            TreeMap<String, String> sorted = new TreeMap<>();
            mnsHeaders.forEach((k, v) -> sorted.put(k.toLowerCase(), v));
            sorted.forEach((k, v) -> canonicalizedHeaders.append(k)
                    .append(":").append(v).append("\n"));
        }

        String stringToSign = method + "\n" + contentMd5 + "\n"
                + contentType + "\n" + date + "\n"
                + canonicalizedHeaders + resource;

        Mac mac = Mac.getInstance("HmacSHA1");
        mac.init(new SecretKeySpec(
                accessKeySecret.getBytes(StandardCharsets.UTF_8), "HmacSHA1"));
        String signature = Base64.getEncoder().encodeToString(
                mac.doFinal(stringToSign.getBytes(StandardCharsets.UTF_8)));

        Map<String, String> headers = new HashMap<>();
        headers.put("Authorization", "MNS " + accessKeyId + ":" + signature);
        headers.put("Date", date);
        headers.put("x-mns-version", "2015-06-06");
        return headers;
    }
}

package main

import (
	"crypto/hmac"
	"crypto/sha1"
	"encoding/base64"
	"fmt"
	"os"
	"sort"
	"strings"
	"time"
)

func signRequest(accessKeyID, accessKeySecret, method, resource,
	contentType, contentMD5 string, mnsHeaders map[string]string) map[string]string {

	date := time.Now().UTC().Format(time.RFC1123)

	// Build CanonicalizedMNSHeaders
	var keys []string
	for k := range mnsHeaders {
		keys = append(keys, strings.ToLower(k))
	}
	sort.Strings(keys)

	var canonicalized strings.Builder
	for _, k := range keys {
		canonicalized.WriteString(fmt.Sprintf("%s:%s\n", k, mnsHeaders[k]))
	}

	stringToSign := fmt.Sprintf("%s\n%s\n%s\n%s\n%s%s",
		method, contentMD5, contentType, date,
		canonicalized.String(), resource)

	mac := hmac.New(sha1.New, []byte(accessKeySecret))
	mac.Write([]byte(stringToSign))
	signature := base64.StdEncoding.EncodeToString(mac.Sum(nil))

	return map[string]string{
		"Authorization": fmt.Sprintf("MNS %s:%s", accessKeyID, signature),
		"Date":          date,
		"x-mns-version": "2015-06-06",
	}
}

func main() {
	headers := signRequest(
		os.Getenv("ALIBABA_CLOUD_ACCESS_KEY_ID"),
		os.Getenv("ALIBABA_CLOUD_ACCESS_KEY_SECRET"),
		"PUT",
		"/queues/examplequeue?metaOverride=true",
		"text/xml", "",
		map[string]string{"x-mns-version": "2015-06-06"},
	)
	for k, v := range headers {
		fmt.Printf("%s: %s\n", k, v)
	}
}