4、签名认证原理：请求参数排序、拼接、哈希计算，Go示例

签名认证是API密钥认证的增强形态，用于防止请求参数在传输过程中被篡改、重放或伪造。其核心思想是：客户端使用共享密钥对请求参数进行排序 → 拼接 → 哈希，生成一个不可逆的签名；服务端用相同算法重新计算签名并比对，只有一致时才放行。

4.1 签名认证三要素

4.2 签名生成标准流程

1. 收集参数：提取所有请求参数（包括 api_key、timestamp、nonce、业务参数等）。
2. 排序：按参数名 ASCII 字典序升序排列。
3. 拼接：将排序后的参数以 key=value 形式用 & 连接成字符串。
4. 加盐：在拼接字符串末尾（或开头）追加共享密钥。
5. 哈希：对完整字符串进行 HMAC-SHA256 或 SHA256 计算，得到十六进制签名。
6. 传输：将签名放入请求头（如 X-Signature）或请求体。

4.3 Go 语言签名实现

以下是一个完整的 Go 签名生成与验证示例，包含参数排序、拼接、HMAC-SHA256 计算和验证函数。

package sign

import (
    "crypto/hmac"
    "crypto/sha256"
    "encoding/hex"
    "fmt"
    "sort"
    "strings"
    "time"
)

// SignParams 签名参数结构
type SignParams struct {
    APIKey    string            // API 密钥标识
    SecretKey string            // 共享密钥
    Timestamp int64             // 时间戳（秒）
    Nonce     string            // 随机字符串
    BizParams map[string]string // 业务参数
}

// GenerateSign 生成签名
func GenerateSign(p SignParams) string {
    // 1. 构建参数 map，包含所有需要签名的参数
    params := make(map[string]string)
    params["api_key"] = p.APIKey
    params["timestamp"] = fmt.Sprintf("%d", p.Timestamp)
    params["nonce"] = p.Nonce
    for k, v := range p.BizParams {
        params[k] = v
    }

    // 2. 提取 key 并排序（字典序 ASC）
    keys := make([]string, 0, len(params))
    for k := range params {
        keys = append(keys, k)
    }
    sort.Strings(keys)

    // 3. 拼接 key=value，用 & 连接
    var sb strings.Builder
    for i, k := range keys {
        if i > 0 {
            sb.WriteByte('&')
        }
        sb.WriteString(k)
        sb.WriteByte('=')
        sb.WriteString(params[k])
    }

    // 4. 追加共享密钥
    sb.WriteString(p.SecretKey)
    rawStr := sb.String()

    // 5. HMAC-SHA256 计算
    mac := hmac.New(sha256.New, []byte(p.SecretKey))
    mac.Write([]byte(rawStr))
    signature := hex.EncodeToString(mac.Sum(nil))

    return signature
}

// VerifySign 验证签名
func VerifySign(p SignParams, receivedSign string) bool {
    expectedSign := GenerateSign(p)
    // 使用 hmac.Equal 防止时序攻击
    return hmac.Equal([]byte(expectedSign), []byte(receivedSign))
}

// 使用示例
func Example() {
    params := SignParams{
        APIKey:    "ak_test_user01",
        SecretKey: "sk_test_abc123xyz",
        Timestamp: time.Now().Unix(),
        Nonce:     "n7f8g9h0",
        BizParams: map[string]string{
            "amount":   "100",
            "currency": "USD",
            "to":       "user_002",
        },
    }

    sign := GenerateSign(params)
    fmt.Printf("Generated Sign: %s\n", sign)

    // 服务端验证
    isValid := VerifySign(params, sign)
    fmt.Printf("Verify Result: %v\n", isValid)
}

4.4 签名验证服务端实现

服务端收到请求后，按以下步骤验证签名有效性：

// VerifyRequest 验证 HTTP 请求签名
func VerifyRequest(apiKey, receivedSign string, timestamp int64, nonce string, bizParams map[string]string) bool {
    // 1. 时间戳防重放：允许 ±300 秒偏差
    now := time.Now().Unix()
    if now-timestamp > 300 || timestamp-now > 300 {
        return false // 请求过期
    }

    // 2. 查询该 api_key 对应的 secret_key（从数据库/缓存）
    secretKey := getSecretKeyByAPIKey(apiKey)
    if secretKey == "" {
        return false
    }

    // 3. 检查 nonce 是否已使用（防重放）
    if isNonceUsed(nonce) {
        return false
    }
    markNonceUsed(nonce)

    // 4. 重新计算签名并比对
    params := SignParams{
        APIKey:    apiKey,
        SecretKey: secretKey,
        Timestamp: timestamp,
        Nonce:     nonce,
        BizParams: bizParams,
    }
    return VerifySign(params, receivedSign)
}

// 模拟密钥查询（生产环境应使用安全存储）
func getSecretKeyByAPIKey(apiKey string) string {
    store := map[string]string{
        "ak_test_user01": "sk_test_abc123xyz",
        "ak_test_user02": "sk_test_def456uvw",
    }
    return store[apiKey]
}

// 模拟 nonce 去重（生产环境应使用 Redis 等）
var usedNonces = make(map[string]struct{})

func isNonceUsed(nonce string) bool {
    _, ok := usedNonces[nonce]
    return ok
}

func markNonceUsed(nonce string) {
    usedNonces[nonce] = struct{}{}
}

4.5 常见签名算法对比

4.6 签名认证边界设计要点

签名认证的边界设计遵循“密钥不出边界，签名验证在服务端”的原则。客户端持有密钥但只传输签名，服务端通过 api_key 索引到对应密钥并重新计算签名。这种设计使得：

• 密钥永不到达网络层：即使 HTTPS 被中间人攻击，攻击者也无法获取密钥。
• 签名与请求绑定：任何参数修改都会导致签名失效。
• 时间窗口 + nonce 双重防重放：即使签名被截获，也无法在窗口外或重复使用。