Skip to content

Golang 示例代码 ​

覆盖「数据安全」两类密钥的核心场景:

  • 数据对称加密密钥(AES-256-GCM):userSignature 生成、sessionKey 解密
  • 数据签名公私钥(RSASSA-PSS):业务数据签名验签(如 gameSignature)

通用说明 ​

  • AES 部分示例分为两层:
    • AES-256-GCM 工具包(aesutil):通用对称加解密实现,与 SUD SDK 内部加解密机制保持一致,可直接复用到任意 AES-256-GCM 场景;
    • 业务封装:基于工具包完成 Payload 构造、字段校验,分别覆盖 userSignature 生成与 sessionKey 解密。
  • AES 字节布局统一为:iv(12) || ciphertext+tag,再整体 Base64 编码(其中 tag 由 gcm.Seal 自动追加在密文末尾,长度 16 字节)。
  • RSA 部分(§3 业务数据签名验签)提供独立的 rsautil 工具包,PSS 参数与 SUD OpenPaaS 服务端签名机制完全一致。
  • 示例仅包含核心逻辑,生产环境需补充日志、异常兜底、监控告警等工程化处理。
  • 业务示例中的 import 路径 your-module/aesutil、your-module/rsautil 请替换为你的实际 Go module 名称。

环境依赖 ​

  • Go 1.15+(无需额外依赖,基于标准库 crypto/aes、crypto/rsa、crypto/x509、encoding/pem)。

通用 AES-256-GCM 工具 ​

go
// file: aesutil/aesutil.go
package aesutil

import (
    "crypto/aes"
    "crypto/cipher"
    "crypto/rand"
    "encoding/base64"
    "fmt"
    "io"
)

const (
    IVLength  = 12
    TagLength = 16
)

func Encrypt(plaintext, keyBase64 string) (string, error) {
    key, err := base64.StdEncoding.DecodeString(keyBase64)
    if err != nil {
        return "", fmt.Errorf("密钥解码失败: %w", err)
    }
    iv, err := generateIV()
    if err != nil {
        return "", err
    }

    block, err := aes.NewCipher(key)
    if err != nil {
        return "", fmt.Errorf("创建 AES 密码块失败: %w", err)
    }
    gcm, err := cipher.NewGCM(block)
    if err != nil {
        return "", fmt.Errorf("创建 GCM 失败: %w", err)
    }

    cipherBytes := gcm.Seal(nil, iv, []byte(plaintext), nil)
    // 与 Java/JCE 一致:iv || ciphertext+tag
    return base64.StdEncoding.EncodeToString(append(iv, cipherBytes...)), nil
}

func Decrypt(encryptedBase64, keyBase64 string) ([]byte, error) {
    key, err := base64.StdEncoding.DecodeString(keyBase64)
    if err != nil {
        return nil, fmt.Errorf("密钥解码失败: %w", err)
    }
    data, err := base64.StdEncoding.DecodeString(encryptedBase64)
    if err != nil {
        return nil, fmt.Errorf("密文解码失败: %w", err)
    }
    iv := data[:IVLength]
    cipherBytes := data[IVLength:]

    block, err := aes.NewCipher(key)
    if err != nil {
        return nil, fmt.Errorf("创建 AES 密码块失败: %w", err)
    }
    gcm, err := cipher.NewGCM(block)
    if err != nil {
        return nil, fmt.Errorf("创建 GCM 失败: %w", err)
    }

    return gcm.Open(nil, iv, cipherBytes, nil)
}

func generateIV() ([]byte, error) {
    iv := make([]byte, IVLength)
    if _, err := io.ReadFull(rand.Reader, iv); err != nil {
        return nil, fmt.Errorf("生成 IV 失败: %w", err)
    }
    return iv, nil
}

1. userSignature 生成 ​

基于 aesutil 构造鉴权 Payload 并加密:

go
// file: usersignature/usersignature.go
package main

import (
    "encoding/json"
    "fmt"
    "time"

    "your-module/aesutil"
)

const signatureVersion = "1"

type signaturePayload struct {
    Version   string `json:"version"`
    UserID    string `json:"user_id"`
    ExpiresAt int64  `json:"expires_at"`
}

func GenerateUserSignature(userID string, expiresAt int64, base64Key string) (string, error) {
    if userID == "" {
        return "", fmt.Errorf("user_id 不能为空")
    }
    if expiresAt <= time.Now().Unix() {
        return "", fmt.Errorf("expires_at 必须为大于当前时间的 Unix 时间戳(秒)")
    }

    payload, err := json.Marshal(signaturePayload{
        Version:   signatureVersion,
        UserID:    userID,
        ExpiresAt: expiresAt,
    })
    if err != nil {
        return "", fmt.Errorf("载荷序列化失败: %w", err)
    }

    return aesutil.Encrypt(string(payload), base64Key)
}

func main() {
    base64Key := "你的Base64编码的32字节AES密钥"
    userID := "user_123456"
    expiresAt := time.Now().Unix() + 24*3600
    sig, err := GenerateUserSignature(userID, expiresAt, base64Key)
    if err != nil {
        fmt.Printf("生成失败: %v\n", err)
        return
    }
    fmt.Println("userSignature:", sig)
}

2. sessionKey 解密 ​

基于 aesutil 解密并校验载荷字段:

go
// file: sessionkey/sessionkey.go
package main

import (
    "encoding/json"
    "fmt"

    "your-module/aesutil"
)

type SessionPayload struct {
    UserID     string `json:"user_id"`
    SessionKey string `json:"session_key"`
}

func DecryptSessionKey(encryptedSessionKey, base64Key, expectedUserID string) (*SessionPayload, error) {
    plaintextBytes, err := aesutil.Decrypt(encryptedSessionKey, base64Key)
    if err != nil {
        return nil, err
    }

    var payload SessionPayload
    if err := json.Unmarshal(plaintextBytes, &payload); err != nil {
        return nil, fmt.Errorf("载荷解析失败: %w", err)
    }
    if payload.UserID == "" || payload.SessionKey == "" {
        return nil, fmt.Errorf("载荷缺少必要字段 user_id / session_key")
    }
    if expectedUserID != "" && payload.UserID != expectedUserID {
        return nil, fmt.Errorf("user_id 不一致: 期望 %s, 实际 %s", expectedUserID, payload.UserID)
    }
    return &payload, nil
}

func main() {
    encryptedSessionKey := "Base64编码的encrypted_session_key"
    base64Key := "你的Base64编码的32字节AES密钥"
    expectedUserID := "user_123456"
    payload, err := DecryptSessionKey(encryptedSessionKey, base64Key, expectedUserID)
    if err != nil {
        fmt.Printf("解密失败: %v\n", err)
        return
    }
    fmt.Printf("user_id: %s, session_key: %s\n", payload.UserID, payload.SessionKey)
}

3. 业务数据签名验签 ​

基于「数据签名公私钥」对 SUD OpenPaaS 下发的业务数据载荷(如 gameSignature)进行 RSASSA-PSS 验签,PSS 参数为 SHA-256 / MGF1-SHA-256 / salt=32 / trailer=1(Go 标准库默认 trailer=1),签名值以 Base64 编码。

3.1 通用 RSA 签名/验签工具 ​

go
// file: rsautil/rsautil.go
package rsautil

import (
    "crypto"
    "crypto/rand"
    "crypto/rsa"
    "crypto/sha256"
    "crypto/x509"
    "encoding/base64"
    "encoding/pem"
    "fmt"
)

var pssOpts = &rsa.PSSOptions{
    SaltLength: 32,
    Hash:       crypto.SHA256,
}

// Sign 使用应用私钥对内容签名,返回 Base64 字符串。
func Sign(content, privateKeyPEM string) (string, error) {
    privateKey, err := parsePrivateKey(privateKeyPEM)
    if err != nil {
        return "", err
    }
    digest := sha256.Sum256([]byte(content))
    sig, err := rsa.SignPSS(rand.Reader, privateKey, crypto.SHA256, digest[:], pssOpts)
    if err != nil {
        return "", fmt.Errorf("RSASSA-PSS 签名失败: %w", err)
    }
    return base64.StdEncoding.EncodeToString(sig), nil
}

// Verify 使用 SUD OpenPaaS 下发的公钥验证签名。
func Verify(content, signValueBase64, publicKeyPEM string) (bool, error) {
    publicKey, err := parsePublicKey(publicKeyPEM)
    if err != nil {
        return false, err
    }
    sig, err := base64.StdEncoding.DecodeString(signValueBase64)
    if err != nil {
        return false, fmt.Errorf("签名 Base64 解码失败: %w", err)
    }
    digest := sha256.Sum256([]byte(content))
    if err := rsa.VerifyPSS(publicKey, crypto.SHA256, digest[:], sig, pssOpts); err != nil {
        return false, nil
    }
    return true, nil
}

func parsePrivateKey(pemStr string) (*rsa.PrivateKey, error) {
    block, _ := pem.Decode([]byte(pemStr))
    if block == nil {
        return nil, fmt.Errorf("私钥 PEM 解码失败")
    }
    if key, err := x509.ParsePKCS8PrivateKey(block.Bytes); err == nil {
        rsaKey, ok := key.(*rsa.PrivateKey)
        if !ok {
            return nil, fmt.Errorf("PKCS#8 私钥不是 RSA 类型")
        }
        return rsaKey, nil
    }
    return x509.ParsePKCS1PrivateKey(block.Bytes)
}

func parsePublicKey(pemStr string) (*rsa.PublicKey, error) {
    block, _ := pem.Decode([]byte(pemStr))
    if block == nil {
        return nil, fmt.Errorf("公钥 PEM 解码失败")
    }
    key, err := x509.ParsePKIXPublicKey(block.Bytes)
    if err != nil {
        return nil, err
    }
    rsaKey, ok := key.(*rsa.PublicKey)
    if !ok {
        return nil, fmt.Errorf("公钥不是 RSA 类型")
    }
    return rsaKey, nil
}

3.2 调用示例 ​

go
// file: verifydata/main.go
package main

import (
    "fmt"

    "your-module/rsautil"
)

func main() {
    // publicKeyPEM:从 SUD OpenPaaS 管理后台获取的应用公钥(PEM 字符串)
    // content:     按对应业务文档(如 gameSignature)拼接的"待验签内容"
    // signature:   业务数据载荷中携带的签名值(Base64)
    publicKeyPEM := "-----BEGIN PUBLIC KEY-----\n...\n-----END PUBLIC KEY-----"
    content := "待验签内容"
    signature := "业务数据中携带的Base64签名值"

    ok, err := rsautil.Verify(content, signature, publicKeyPEM)
    if err != nil {
        fmt.Printf("验签异常: %v\n", err)
        return
    }
    if !ok {
        fmt.Println("数据验签失败,请勿信任该业务数据内容")
        return
    }
    fmt.Println("数据验签通过")
}