606 lines
19 KiB
Go
606 lines
19 KiB
Go
package service
|
||
|
||
import (
|
||
"carrotskin/internal/model"
|
||
"carrotskin/internal/repository"
|
||
"carrotskin/pkg/redis"
|
||
"context"
|
||
"crypto"
|
||
"crypto/rand"
|
||
"crypto/rsa"
|
||
"crypto/sha1"
|
||
"crypto/x509"
|
||
"encoding/base64"
|
||
"encoding/binary"
|
||
"encoding/pem"
|
||
"fmt"
|
||
"go.uber.org/zap"
|
||
"strconv"
|
||
"strings"
|
||
"time"
|
||
|
||
"gorm.io/gorm"
|
||
)
|
||
|
||
// 常量定义
|
||
const (
|
||
// RSA密钥长度
|
||
RSAKeySize = 4096
|
||
|
||
// Redis密钥名称
|
||
PrivateKeyRedisKey = "private_key"
|
||
PublicKeyRedisKey = "public_key"
|
||
|
||
// 密钥过期时间
|
||
KeyExpirationTime = time.Hour * 24 * 7
|
||
|
||
// 证书相关
|
||
CertificateRefreshInterval = time.Hour * 24 // 证书刷新时间间隔
|
||
CertificateExpirationPeriod = time.Hour * 24 * 7 // 证书过期时间
|
||
)
|
||
|
||
// PlayerCertificate 表示玩家证书信息
|
||
type PlayerCertificate struct {
|
||
ExpiresAt string `json:"expiresAt"`
|
||
RefreshedAfter string `json:"refreshedAfter"`
|
||
PublicKeySignature string `json:"publicKeySignature,omitempty"`
|
||
PublicKeySignatureV2 string `json:"publicKeySignatureV2,omitempty"`
|
||
KeyPair struct {
|
||
PrivateKey string `json:"privateKey"`
|
||
PublicKey string `json:"publicKey"`
|
||
} `json:"keyPair"`
|
||
}
|
||
// SignatureService 保留结构体以保持向后兼容，但推荐使用函数式版本
|
||
type SignatureService struct {
|
||
logger *zap.Logger
|
||
redisClient *redis.Client
|
||
}
|
||
|
||
func NewSignatureService(logger *zap.Logger, redisClient *redis.Client) *SignatureService {
|
||
return &SignatureService{
|
||
logger: logger,
|
||
redisClient: redisClient,
|
||
}
|
||
}
|
||
|
||
// SignStringWithSHA1withRSA 使用SHA1withRSA签名字符串并返回Base64编码的签名（函数式版本）
|
||
func SignStringWithSHA1withRSA(logger *zap.Logger, redisClient *redis.Client, data string) (string, error) {
|
||
if data == "" {
|
||
return "", fmt.Errorf("签名数据不能为空")
|
||
}
|
||
|
||
// 获取私钥
|
||
privateKey, err := DecodePrivateKeyFromPEM(logger, redisClient)
|
||
if err != nil {
|
||
logger.Error("[ERROR] 解码私钥失败: ", zap.Error(err))
|
||
return "", fmt.Errorf("解码私钥失败: %w", err)
|
||
}
|
||
|
||
// 计算SHA1哈希
|
||
hashed := sha1.Sum([]byte(data))
|
||
|
||
// 使用RSA-PKCS1v15算法签名
|
||
signature, err := rsa.SignPKCS1v15(rand.Reader, privateKey, crypto.SHA1, hashed[:])
|
||
if err != nil {
|
||
logger.Error("[ERROR] RSA签名失败: ", zap.Error(err))
|
||
return "", fmt.Errorf("RSA签名失败: %w", err)
|
||
}
|
||
|
||
// Base64编码签名
|
||
encodedSignature := base64.StdEncoding.EncodeToString(signature)
|
||
|
||
logger.Info("[INFO] 成功使用SHA1withRSA生成签名,", zap.Any("数据长度：", len(data)))
|
||
return encodedSignature, nil
|
||
}
|
||
|
||
// SignStringWithSHA1withRSAService 使用SHA1withRSA签名字符串并返回Base64编码的签名（结构体方法版本，保持向后兼容）
|
||
func (s *SignatureService) SignStringWithSHA1withRSA(data string) (string, error) {
|
||
return SignStringWithSHA1withRSA(s.logger, s.redisClient, data)
|
||
}
|
||
|
||
// DecodePrivateKeyFromPEM 从Redis获取并解码PEM格式的私钥（函数式版本）
|
||
func DecodePrivateKeyFromPEM(logger *zap.Logger, redisClient *redis.Client) (*rsa.PrivateKey, error) {
|
||
// 从Redis获取私钥
|
||
privateKeyString, err := GetPrivateKeyFromRedis(logger, redisClient)
|
||
if err != nil {
|
||
return nil, fmt.Errorf("从Redis获取私钥失败: %w", err)
|
||
}
|
||
|
||
// 解码PEM格式
|
||
privateKeyBlock, rest := pem.Decode([]byte(privateKeyString))
|
||
if privateKeyBlock == nil || len(rest) > 0 {
|
||
logger.Error("[ERROR] 无效的PEM格式私钥")
|
||
return nil, fmt.Errorf("无效的PEM格式私钥")
|
||
}
|
||
|
||
// 解析PKCS1格式的私钥
|
||
privateKey, err := x509.ParsePKCS1PrivateKey(privateKeyBlock.Bytes)
|
||
if err != nil {
|
||
logger.Error("[ERROR] 解析私钥失败: ", zap.Error(err))
|
||
return nil, fmt.Errorf("解析私钥失败: %w", err)
|
||
}
|
||
|
||
return privateKey, nil
|
||
}
|
||
|
||
// GetPrivateKeyFromRedis 从Redis获取私钥（PEM格式）（函数式版本）
|
||
func GetPrivateKeyFromRedis(logger *zap.Logger, redisClient *redis.Client) (string, error) {
|
||
ctx, cancel := context.WithTimeout(context.Background(), DefaultTimeout)
|
||
defer cancel()
|
||
|
||
pemBytes, err := redisClient.GetBytes(ctx, PrivateKeyRedisKey)
|
||
if err != nil {
|
||
logger.Info("[INFO] 从Redis获取私钥失败，尝试生成新的密钥对: ", zap.Error(err))
|
||
|
||
// 生成新的密钥对
|
||
err = GenerateRSAKeyPair(logger, redisClient)
|
||
if err != nil {
|
||
logger.Error("[ERROR] 生成RSA密钥对失败: ", zap.Error(err))
|
||
return "", fmt.Errorf("生成RSA密钥对失败: %w", err)
|
||
}
|
||
|
||
// 递归获取生成的密钥
|
||
return GetPrivateKeyFromRedis(logger, redisClient)
|
||
}
|
||
|
||
return string(pemBytes), nil
|
||
}
|
||
|
||
// DecodePrivateKeyFromPEMService 从Redis获取并解码PEM格式的私钥（结构体方法版本，保持向后兼容）
|
||
func (s *SignatureService) DecodePrivateKeyFromPEM() (*rsa.PrivateKey, error) {
|
||
return DecodePrivateKeyFromPEM(s.logger, s.redisClient)
|
||
}
|
||
|
||
// GetPrivateKeyFromRedisService 从Redis获取私钥（PEM格式）（结构体方法版本，保持向后兼容）
|
||
func (s *SignatureService) GetPrivateKeyFromRedis() (string, error) {
|
||
return GetPrivateKeyFromRedis(s.logger, s.redisClient)
|
||
}
|
||
|
||
// GenerateRSAKeyPair 生成新的RSA密钥对（函数式版本）
|
||
func GenerateRSAKeyPair(logger *zap.Logger, redisClient *redis.Client) error {
|
||
logger.Info("[INFO] 开始生成RSA密钥对", zap.Int("keySize", RSAKeySize))
|
||
|
||
// 生成私钥
|
||
privateKey, err := rsa.GenerateKey(rand.Reader, RSAKeySize)
|
||
if err != nil {
|
||
logger.Error("[ERROR] 生成RSA私钥失败: ", zap.Error(err))
|
||
return fmt.Errorf("生成RSA私钥失败: %w", err)
|
||
}
|
||
|
||
// 编码私钥为PEM格式
|
||
pemPrivateKey, err := EncodePrivateKeyToPEM(privateKey)
|
||
if err != nil {
|
||
logger.Error("[ERROR] 编码RSA私钥失败: ", zap.Error(err))
|
||
return fmt.Errorf("编码RSA私钥失败: %w", err)
|
||
}
|
||
|
||
// 获取公钥并编码为PEM格式
|
||
pubKey := privateKey.PublicKey
|
||
pemPublicKey, err := EncodePublicKeyToPEM(logger, &pubKey)
|
||
if err != nil {
|
||
logger.Error("[ERROR] 编码RSA公钥失败: ", zap.Error(err))
|
||
return fmt.Errorf("编码RSA公钥失败: %w", err)
|
||
}
|
||
|
||
// 保存密钥对到Redis
|
||
return SaveKeyPairToRedis(logger, redisClient, string(pemPrivateKey), string(pemPublicKey))
|
||
}
|
||
|
||
// GenerateRSAKeyPairService 生成新的RSA密钥对（结构体方法版本，保持向后兼容）
|
||
func (s *SignatureService) GenerateRSAKeyPair() error {
|
||
return GenerateRSAKeyPair(s.logger, s.redisClient)
|
||
}
|
||
|
||
// EncodePrivateKeyToPEM 将私钥编码为PEM格式（函数式版本）
|
||
func EncodePrivateKeyToPEM(privateKey *rsa.PrivateKey, keyType ...string) ([]byte, error) {
|
||
if privateKey == nil {
|
||
return nil, fmt.Errorf("私钥不能为空")
|
||
}
|
||
|
||
// 默认使用 "PRIVATE KEY" 类型
|
||
pemType := "PRIVATE KEY"
|
||
|
||
// 如果指定了类型参数且为 "RSA"，则使用 "RSA PRIVATE KEY"
|
||
if len(keyType) > 0 && keyType[0] == "RSA" {
|
||
pemType = "RSA PRIVATE KEY"
|
||
}
|
||
|
||
// 将私钥转换为PKCS1格式
|
||
privateKeyBytes := x509.MarshalPKCS1PrivateKey(privateKey)
|
||
|
||
// 编码为PEM格式
|
||
pemBlock := &pem.Block{
|
||
Type: pemType,
|
||
Bytes: privateKeyBytes,
|
||
}
|
||
|
||
return pem.EncodeToMemory(pemBlock), nil
|
||
}
|
||
|
||
// EncodePublicKeyToPEM 将公钥编码为PEM格式（函数式版本）
|
||
func EncodePublicKeyToPEM(logger *zap.Logger, publicKey *rsa.PublicKey, keyType ...string) ([]byte, error) {
|
||
if publicKey == nil {
|
||
return nil, fmt.Errorf("公钥不能为空")
|
||
}
|
||
|
||
// 默认使用 "PUBLIC KEY" 类型
|
||
pemType := "PUBLIC KEY"
|
||
var publicKeyBytes []byte
|
||
var err error
|
||
|
||
// 如果指定了类型参数且为 "RSA"，则使用 "RSA PUBLIC KEY"
|
||
if len(keyType) > 0 && keyType[0] == "RSA" {
|
||
pemType = "RSA PUBLIC KEY"
|
||
publicKeyBytes = x509.MarshalPKCS1PublicKey(publicKey)
|
||
} else {
|
||
// 默认将公钥转换为PKIX格式
|
||
publicKeyBytes, err = x509.MarshalPKIXPublicKey(publicKey)
|
||
if err != nil {
|
||
logger.Error("[ERROR] 序列化公钥失败: ", zap.Error(err))
|
||
return nil, fmt.Errorf("序列化公钥失败: %w", err)
|
||
}
|
||
}
|
||
|
||
// 编码为PEM格式
|
||
pemBlock := &pem.Block{
|
||
Type: pemType,
|
||
Bytes: publicKeyBytes,
|
||
}
|
||
|
||
return pem.EncodeToMemory(pemBlock), nil
|
||
}
|
||
|
||
// SaveKeyPairToRedis 将RSA密钥对保存到Redis（函数式版本）
|
||
func SaveKeyPairToRedis(logger *zap.Logger, redisClient *redis.Client, privateKey, publicKey string) error {
|
||
// 创建上下文并设置超时
|
||
ctx, cancel := context.WithTimeout(context.Background(), DefaultTimeout)
|
||
defer cancel()
|
||
|
||
// 使用事务确保两个操作的原子性
|
||
tx := redisClient.TxPipeline()
|
||
|
||
tx.Set(ctx, PrivateKeyRedisKey, privateKey, KeyExpirationTime)
|
||
tx.Set(ctx, PublicKeyRedisKey, publicKey, KeyExpirationTime)
|
||
|
||
// 执行事务
|
||
_, err := tx.Exec(ctx)
|
||
if err != nil {
|
||
logger.Error("[ERROR] 保存RSA密钥对到Redis失败: ", zap.Error(err))
|
||
return fmt.Errorf("保存RSA密钥对到Redis失败: %w", err)
|
||
}
|
||
|
||
logger.Info("[INFO] 成功保存RSA密钥对到Redis")
|
||
return nil
|
||
}
|
||
|
||
// EncodePrivateKeyToPEMService 将私钥编码为PEM格式（结构体方法版本，保持向后兼容）
|
||
func (s *SignatureService) EncodePrivateKeyToPEM(privateKey *rsa.PrivateKey, keyType ...string) ([]byte, error) {
|
||
return EncodePrivateKeyToPEM(privateKey, keyType...)
|
||
}
|
||
|
||
// EncodePublicKeyToPEMService 将公钥编码为PEM格式（结构体方法版本，保持向后兼容）
|
||
func (s *SignatureService) EncodePublicKeyToPEM(publicKey *rsa.PublicKey, keyType ...string) ([]byte, error) {
|
||
return EncodePublicKeyToPEM(s.logger, publicKey, keyType...)
|
||
}
|
||
|
||
// SaveKeyPairToRedisService 将RSA密钥对保存到Redis（结构体方法版本，保持向后兼容）
|
||
func (s *SignatureService) SaveKeyPairToRedis(privateKey, publicKey string) error {
|
||
return SaveKeyPairToRedis(s.logger, s.redisClient, privateKey, publicKey)
|
||
}
|
||
|
||
// GetPublicKeyFromRedisFunc 从Redis获取公钥（PEM格式，函数式版本）
|
||
func GetPublicKeyFromRedisFunc(logger *zap.Logger, redisClient *redis.Client) (string, error) {
|
||
ctx, cancel := context.WithTimeout(context.Background(), DefaultTimeout)
|
||
defer cancel()
|
||
|
||
pemBytes, err := redisClient.GetBytes(ctx, PublicKeyRedisKey)
|
||
if err != nil {
|
||
logger.Info("[INFO] 从Redis获取公钥失败，尝试生成新的密钥对: ", zap.Error(err))
|
||
|
||
// 生成新的密钥对
|
||
err = GenerateRSAKeyPair(logger, redisClient)
|
||
if err != nil {
|
||
logger.Error("[ERROR] 生成RSA密钥对失败: ", zap.Error(err))
|
||
return "", fmt.Errorf("生成RSA密钥对失败: %w", err)
|
||
}
|
||
|
||
// 递归获取生成的密钥
|
||
return GetPublicKeyFromRedisFunc(logger, redisClient)
|
||
}
|
||
|
||
// 检查获取到的公钥是否为空（key不存在时GetBytes返回nil, nil）
|
||
if len(pemBytes) == 0 {
|
||
logger.Info("[INFO] Redis中公钥为空，尝试生成新的密钥对")
|
||
// 生成新的密钥对
|
||
err = GenerateRSAKeyPair(logger, redisClient)
|
||
if err != nil {
|
||
logger.Error("[ERROR] 生成RSA密钥对失败: ", zap.Error(err))
|
||
return "", fmt.Errorf("生成RSA密钥对失败: %w", err)
|
||
}
|
||
// 递归获取生成的密钥
|
||
return GetPublicKeyFromRedisFunc(logger, redisClient)
|
||
}
|
||
|
||
return string(pemBytes), nil
|
||
}
|
||
|
||
// GetPublicKeyFromRedis 从Redis获取公钥（PEM格式，结构体方法版本）
|
||
func (s *SignatureService) GetPublicKeyFromRedis() (string, error) {
|
||
return GetPublicKeyFromRedisFunc(s.logger, s.redisClient)
|
||
}
|
||
|
||
|
||
// GeneratePlayerCertificate 生成玩家证书（函数式版本）
|
||
func GeneratePlayerCertificate(db *gorm.DB, logger *zap.Logger, redisClient *redis.Client, uuid string) (*PlayerCertificate, error) {
|
||
if uuid == "" {
|
||
return nil, fmt.Errorf("UUID不能为空")
|
||
}
|
||
logger.Info("[INFO] 开始生成玩家证书，用户UUID: %s",
|
||
zap.String("uuid", uuid),
|
||
)
|
||
|
||
keyPair, err := repository.GetProfileKeyPair(uuid)
|
||
if err != nil {
|
||
logger.Info("[INFO] 获取用户密钥对失败，将创建新密钥对: %v",
|
||
zap.Error(err),
|
||
zap.String("uuid", uuid),
|
||
)
|
||
keyPair = nil
|
||
}
|
||
|
||
// 如果没有找到密钥对或密钥对已过期，创建一个新的
|
||
now := time.Now().UTC()
|
||
if keyPair == nil || keyPair.Refresh.Before(now) || keyPair.PrivateKey == "" || keyPair.PublicKey == "" {
|
||
logger.Info("[INFO] 为用户创建新的密钥对: %s",
|
||
zap.String("uuid", uuid),
|
||
)
|
||
keyPair, err = NewKeyPair(logger)
|
||
if err != nil {
|
||
logger.Error("[ERROR] 生成玩家证书密钥对失败: %v",
|
||
zap.Error(err),
|
||
zap.String("uuid", uuid),
|
||
)
|
||
return nil, fmt.Errorf("生成玩家证书密钥对失败: %w", err)
|
||
}
|
||
// 保存密钥对到数据库
|
||
err = repository.UpdateProfileKeyPair(uuid, keyPair)
|
||
if err != nil {
|
||
// 日志修改：logger → s.logger，zap结构化字段
|
||
logger.Warn("[WARN] 更新用户密钥对失败: %v",
|
||
zap.Error(err),
|
||
zap.String("uuid", uuid),
|
||
)
|
||
// 继续执行，即使保存失败
|
||
}
|
||
}
|
||
|
||
// 计算expiresAt的毫秒时间戳
|
||
expiresAtMillis := keyPair.Expiration.UnixMilli()
|
||
|
||
// 准备签名
|
||
publicKeySignature := ""
|
||
publicKeySignatureV2 := ""
|
||
|
||
// 获取服务器私钥用于签名
|
||
serverPrivateKey, err := DecodePrivateKeyFromPEM(logger, redisClient)
|
||
if err != nil {
|
||
// 日志修改：logger → s.logger，zap结构化字段
|
||
logger.Error("[ERROR] 获取服务器私钥失败: %v",
|
||
zap.Error(err),
|
||
zap.String("uuid", uuid),
|
||
)
|
||
return nil, fmt.Errorf("获取服务器私钥失败: %w", err)
|
||
}
|
||
|
||
// 提取公钥DER编码
|
||
pubPEMBlock, _ := pem.Decode([]byte(keyPair.PublicKey))
|
||
if pubPEMBlock == nil {
|
||
// 日志修改：logger → s.logger，zap结构化字段
|
||
logger.Error("[ERROR] 解码公钥PEM失败",
|
||
zap.String("uuid", uuid),
|
||
zap.String("publicKey", keyPair.PublicKey),
|
||
)
|
||
return nil, fmt.Errorf("解码公钥PEM失败")
|
||
}
|
||
pubDER := pubPEMBlock.Bytes
|
||
|
||
// 准备publicKeySignature（用于MC 1.19）
|
||
// Base64编码公钥，不包含换行
|
||
pubBase64 := strings.ReplaceAll(base64.StdEncoding.EncodeToString(pubDER), "\n", "")
|
||
|
||
// 按76字符一行进行包装
|
||
pubBase64Wrapped := WrapString(pubBase64, 76)
|
||
|
||
// 放入PEM格式
|
||
pubMojangPEM := "-----BEGIN RSA PUBLIC KEY-----\n" +
|
||
pubBase64Wrapped +
|
||
"\n-----END RSA PUBLIC KEY-----\n"
|
||
|
||
// 签名数据: expiresAt毫秒时间戳 + 公钥PEM格式
|
||
signedData := []byte(fmt.Sprintf("%d%s", expiresAtMillis, pubMojangPEM))
|
||
|
||
// 计算SHA1哈希并签名
|
||
hash1 := sha1.Sum(signedData)
|
||
signature, err := rsa.SignPKCS1v15(rand.Reader, serverPrivateKey, crypto.SHA1, hash1[:])
|
||
if err != nil {
|
||
logger.Error("[ERROR] 签名失败: %v",
|
||
zap.Error(err),
|
||
zap.String("uuid", uuid),
|
||
zap.Int64("expiresAtMillis", expiresAtMillis),
|
||
)
|
||
return nil, fmt.Errorf("签名失败: %w", err)
|
||
}
|
||
publicKeySignature = base64.StdEncoding.EncodeToString(signature)
|
||
|
||
// 准备publicKeySignatureV2（用于MC 1.19.1+）
|
||
var uuidBytes []byte
|
||
|
||
// 如果提供了UUID，则使用它
|
||
// 移除UUID中的连字符
|
||
uuidStr := strings.ReplaceAll(uuid, "-", "")
|
||
|
||
// 将UUID转换为字节数组（16字节）
|
||
if len(uuidStr) < 32 {
|
||
logger.Warn("[WARN] UUID长度不足32字符，使用空UUID: %s",
|
||
zap.String("uuid", uuid),
|
||
zap.String("processedUuidStr", uuidStr),
|
||
)
|
||
uuidBytes = make([]byte, 16)
|
||
} else {
|
||
// 解析UUID字符串为字节
|
||
uuidBytes = make([]byte, 16)
|
||
parseErr := error(nil)
|
||
for i := 0; i < 16; i++ {
|
||
// 每两个字符转换为一个字节
|
||
byteStr := uuidStr[i*2 : i*2+2]
|
||
byteVal, err := strconv.ParseUint(byteStr, 16, 8)
|
||
if err != nil {
|
||
parseErr = err
|
||
logger.Error("[ERROR] 解析UUID字节失败: %v, byteStr: %s",
|
||
zap.Error(err),
|
||
zap.String("uuid", uuid),
|
||
zap.String("byteStr", byteStr),
|
||
zap.Int("index", i),
|
||
)
|
||
uuidBytes = make([]byte, 16) // 出错时使用空UUID
|
||
break
|
||
}
|
||
uuidBytes[i] = byte(byteVal)
|
||
}
|
||
if parseErr != nil {
|
||
return nil, fmt.Errorf("解析UUID字节失败: %w", parseErr)
|
||
}
|
||
}
|
||
|
||
// 准备签名数据：UUID + expiresAt时间戳 + DER编码的公钥
|
||
signedDataV2 := make([]byte, 0, 24+len(pubDER)) // 预分配缓冲区
|
||
|
||
// 添加UUID（16字节）
|
||
signedDataV2 = append(signedDataV2, uuidBytes...)
|
||
|
||
// 添加expiresAt毫秒时间戳（8字节，大端序）
|
||
expiresAtBytes := make([]byte, 8)
|
||
binary.BigEndian.PutUint64(expiresAtBytes, uint64(expiresAtMillis))
|
||
signedDataV2 = append(signedDataV2, expiresAtBytes...)
|
||
|
||
// 添加DER编码的公钥
|
||
signedDataV2 = append(signedDataV2, pubDER...)
|
||
|
||
// 计算SHA1哈希并签名
|
||
hash2 := sha1.Sum(signedDataV2)
|
||
signatureV2, err := rsa.SignPKCS1v15(rand.Reader, serverPrivateKey, crypto.SHA1, hash2[:])
|
||
if err != nil {
|
||
logger.Error("[ERROR] 签名V2失败: %v",
|
||
zap.Error(err),
|
||
zap.String("uuid", uuid),
|
||
zap.Int64("expiresAtMillis", expiresAtMillis),
|
||
)
|
||
return nil, fmt.Errorf("签名V2失败: %w", err)
|
||
}
|
||
publicKeySignatureV2 = base64.StdEncoding.EncodeToString(signatureV2)
|
||
|
||
// 创建玩家证书结构
|
||
certificate := &PlayerCertificate{
|
||
KeyPair: struct {
|
||
PrivateKey string `json:"privateKey"`
|
||
PublicKey string `json:"publicKey"`
|
||
}{
|
||
PrivateKey: keyPair.PrivateKey,
|
||
PublicKey: keyPair.PublicKey,
|
||
},
|
||
PublicKeySignature: publicKeySignature,
|
||
PublicKeySignatureV2: publicKeySignatureV2,
|
||
ExpiresAt: keyPair.Expiration.Format(time.RFC3339Nano),
|
||
RefreshedAfter: keyPair.Refresh.Format(time.RFC3339Nano),
|
||
}
|
||
|
||
logger.Info("[INFO] 成功生成玩家证书，过期时间: %s",
|
||
zap.String("uuid", uuid),
|
||
zap.String("expiresAt", certificate.ExpiresAt),
|
||
zap.String("refreshedAfter", certificate.RefreshedAfter),
|
||
)
|
||
return certificate, nil
|
||
}
|
||
|
||
// GeneratePlayerCertificateService 生成玩家证书（结构体方法版本，保持向后兼容）
|
||
func (s *SignatureService) GeneratePlayerCertificate(uuid string) (*PlayerCertificate, error) {
|
||
return GeneratePlayerCertificate(nil, s.logger, s.redisClient, uuid) // TODO: 需要传入db参数
|
||
}
|
||
|
||
// NewKeyPair 生成新的密钥对（函数式版本）
|
||
func NewKeyPair(logger *zap.Logger) (*model.KeyPair, error) {
|
||
// 生成新的RSA密钥对（用于玩家证书）
|
||
privateKey, err := rsa.GenerateKey(rand.Reader, 2048) // 对玩家证书使用更小的密钥以提高性能
|
||
if err != nil {
|
||
logger.Error("[ERROR] 生成玩家证书私钥失败: %v",
|
||
zap.Error(err),
|
||
)
|
||
return nil, fmt.Errorf("生成玩家证书私钥失败: %w", err)
|
||
}
|
||
|
||
// 获取DER编码的密钥
|
||
keyDER, err := x509.MarshalPKCS8PrivateKey(privateKey)
|
||
if err != nil {
|
||
logger.Error("[ERROR] 编码私钥为PKCS8格式失败: %v",
|
||
zap.Error(err),
|
||
)
|
||
return nil, fmt.Errorf("编码私钥为PKCS8格式失败: %w", err)
|
||
}
|
||
|
||
pubDER, err := x509.MarshalPKIXPublicKey(&privateKey.PublicKey)
|
||
if err != nil {
|
||
logger.Error("[ERROR] 编码公钥为PKIX格式失败: %v",
|
||
zap.Error(err),
|
||
)
|
||
return nil, fmt.Errorf("编码公钥为PKIX格式失败: %w", err)
|
||
}
|
||
|
||
// 将密钥编码为PEM格式
|
||
keyPEM := pem.EncodeToMemory(&pem.Block{
|
||
Type: "RSA PRIVATE KEY",
|
||
Bytes: keyDER,
|
||
})
|
||
|
||
pubPEM := pem.EncodeToMemory(&pem.Block{
|
||
Type: "RSA PUBLIC KEY",
|
||
Bytes: pubDER,
|
||
})
|
||
|
||
// 创建证书过期和刷新时间
|
||
now := time.Now().UTC()
|
||
expiresAtTime := now.Add(CertificateExpirationPeriod)
|
||
refreshedAfter := now.Add(CertificateRefreshInterval)
|
||
keyPair := &model.KeyPair{
|
||
Expiration: expiresAtTime,
|
||
PrivateKey: string(keyPEM),
|
||
PublicKey: string(pubPEM),
|
||
Refresh: refreshedAfter,
|
||
}
|
||
return keyPair, nil
|
||
}
|
||
|
||
// WrapString 将字符串按指定宽度进行换行（函数式版本）
|
||
func WrapString(str string, width int) string {
|
||
if width <= 0 {
|
||
return str
|
||
}
|
||
|
||
var b strings.Builder
|
||
for i := 0; i < len(str); i += width {
|
||
end := i + width
|
||
if end > len(str) {
|
||
end = len(str)
|
||
}
|
||
b.WriteString(str[i:end])
|
||
if end < len(str) {
|
||
b.WriteString("\n")
|
||
}
|
||
}
|
||
return b.String()
|
||
}
|
||
|
||
// NewKeyPairService 生成新的密钥对（结构体方法版本，保持向后兼容）
|
||
func (s *SignatureService) NewKeyPair() (*model.KeyPair, error) {
|
||
return NewKeyPair(s.logger)
|
||
}
|