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("数据验签通过")
}