"x-bili-accesskeyid:$accesskeyidValue"
"x-bili-content-md5:$contentMd5Value"
"x-bili-signature-method:HMAC-SHA256"
"x-bili-signature-nonce:$signatureNonceValue"
"x-bili-signature-version:2.0"
"x-bili-timestamp:$timestamp"

x-bili-accesskeyid:xxxx
x-bili-content-md5:fa6837e35b2f591865b288dfd859ce9d
x-bili-signature-method:HMAC-SHA256
x-bili-signature-nonce:ad184c09-095f-91c3-0849-230dd3744045
x-bili-signature-version:2.0
x-bili-timestamp:1624594467

func HmacSHA256(key string, data string) string {
    mac := hmac.New(sha256.New, []byte(key))
    mac.Write([]byte(data))
    return hex.EncodeToString(mac.Sum(nil))
}

package main

import (
    "crypto/hmac"
    "crypto/md5"
    "crypto/sha256"
    "encoding/hex"
    "encoding/json"
    "fmt"
    "github.com/monaco-io/request"
    "sort"
    "strconv"
    "strings"
    "time"
)

type BaseResp struct {
    Code      int64       `json:"code"`
    Message   string      `json:"message"`
    RequestId string      `json:"request_id"`
    Data      interface{} `json:"data"`
}

const (
    ClientIdProd    = "yourclientid"
    AppSecretProd   = "yoursecret"
    AccessTokenProd = "youraccesstoken"
)

const (
    AcceptHeader              = "Accept"
    ContentTypeHeader         = "Content-Type"
    AuthorizationHeader       = "Authorization"
    JsonType                  = "application/json"
    HmacSha256                = "HMAC-SHA256"
    BiliTimestampHeader       = "x-bili-timestamp"
    BiliSignatureMethodHeader = "x-bili-signature-method"
    BiliSignatureNonceHeader  = "x-bili-signature-nonce"
    BiliAccessKeyIdHeader     = "x-bili-accesskeyid"
    BiliSignVersionHeader     = "x-bili-signature-version"
    BiliContentMD5Header      = "x-bili-content-md5"
    AccessToken               = "access-token"
    BiliVersionV2             = "2.0"

    MainOpenPlatformHttpHost = "https://member.bilibili.com"

)

type CommonHeader struct {
    ContentType       string
    ContentAcceptType string
    Timestamp         string
    SignatureMethod   string
    SignatureVersion  string
    Authorization     string
    Nonce             string
    AccessKeyId       string
    ContentMD5        string
    X1BilispyColor    string
    AccessToken       string
}



// ApiRequestV2 http request demo方法
func ApiRequestV2(reqJson, requestUrl string) (resp BaseResp, err error) {
    resp = BaseResp{}
    header := &CommonHeader{
       AccessToken:       AccessTokenProd,
       ContentType:       JsonType,
       ContentAcceptType: JsonType,
       Timestamp:         strconv.FormatInt(time.Now().Unix(), 10),
       SignatureMethod:   HmacSha256,
       SignatureVersion:  BiliVersionV2,
       Authorization:     "",
       Nonce:             strconv.FormatInt(time.Now().UnixNano(), 10), //用于幂等,记得替换
       AccessKeyId:       ClientIdProd,
       ContentMD5:        Md5(reqJson),
       //X1BilispyColor:    model.Color,
    }
    header.Authorization = CreateSignature(header, AppSecretProd)
    cli := request.Client{
       Method: "POST",
       URL:    fmt.Sprintf("%s%s", MainOpenPlatformHttpHost, requestUrl),
       Header: ToMap(header),
       String: reqJson,
    }

    // 打印请求的cURL命令
    fmt.Println("cURL Command:")
    cli.PrintCURL()

    var respTest interface{}
    cliResp := cli.Send().Scan(&respTest)
    if !cliResp.OK() {
       err = fmt.Errorf("[error] req:%+v resp:%+v err:%+v", reqJson, resp, cliResp.Error())
    }
    // 使用json.MarshalIndent来格式化JSON数据
    jsonData, err := json.MarshalIndent(respTest, "", "    ")
    if err != nil {
       fmt.Println("Error marshaling JSON:", err)
       return
    }

    // 打印格式化后的JSON字符串
    fmt.Println(string(jsonData))
    return
}

// CreateSignature 生成Authorization加密串
func CreateSignature(header *CommonHeader, accessKeySecret string) string {
    sStr := ToSortedString(header)
    return HmacSHA256(accessKeySecret, sStr)
}

// Md5 md5加密
func Md5(str string) (md5str string) {
    data := []byte(str)
    has := md5.Sum(data)
    md5str = fmt.Sprintf("%x", has)
    return md5str
}

// HmacSHA256 HMAC-SHA256算法
func HmacSHA256(key string, data string) string {
    mac := hmac.New(sha256.New, []byte(key))
    mac.Write([]byte(data))
    return hex.EncodeToString(mac.Sum(nil))
}

// ToMap 所有字段转map<string, string>
func ToMap(h *CommonHeader) map[string]string {
    return map[string]string{
       BiliTimestampHeader:       h.Timestamp,
       BiliSignatureMethodHeader: h.SignatureMethod,
       BiliSignatureNonceHeader:  h.Nonce,
       BiliAccessKeyIdHeader:     h.AccessKeyId,
       BiliSignVersionHeader:     h.SignatureVersion,
       BiliContentMD5Header:      h.ContentMD5,
       AuthorizationHeader:       h.Authorization,
        ContentTypeHeader:         h.ContentType,
       AcceptHeader:              h.ContentAcceptType,
       AccessToken: h.AccessToken,
    }
}

// ToSortMap 参与加密的字段转map<string, string>
func ToSortMap(h *CommonHeader) map[string]string {
    return map[string]string{
       BiliTimestampHeader:       h.Timestamp,
       BiliSignatureMethodHeader: h.SignatureMethod,
       BiliSignatureNonceHeader:  h.Nonce,
       BiliAccessKeyIdHeader:     h.AccessKeyId,
       BiliSignVersionHeader:     h.SignatureVersion,
       BiliContentMD5Header:      h.ContentMD5,
    }
}

// ToSortedString 生成需要加密的文本
func ToSortedString(h *CommonHeader) (sign string) {
    hMap := ToSortMap(h)
    var hSil []string
    for k := range hMap {
       hSil = append(hSil, k)
    }
    sort.Strings(hSil)
    for _, v := range hSil {
       sign += v + ":" + hMap[v] + "\n"
    }
    sign = strings.TrimRight(sign, "\n")
    return
}