package jwtutil import ( "crypto/rsa" "encoding/base64" "errors" "fmt" "math/big" "os" "strings" "sync" "time" beego "github.com/beego/beego/v2/server/web" "github.com/golang-jwt/jwt/v5" ) const ( AlgHS256 = "HS256" AlgRS256 = "RS256" ) const DefaultKid = "default" // legacySecret 兼容用的内置密钥:仅用于解析历史已签发的 token。 // 生产环境必须在 app.conf 中配置 jwt_secret,否则会一直使用该固定值。 const legacySecret = "yunzer_jwt_secret_key" type Claims struct { UserID int `json:"user_id"` Username string `json:"username"` TenantId int `json:"tenant_id"` UserType string `json:"user_type"` ClientID string `json:"client_id,omitempty"` Sid string `json:"sid,omitempty"` Scope string `json:"scope,omitempty"` Amr string `json:"amr,omitempty"` Events map[string]interface{} `json:"events,omitempty"` jwt.RegisteredClaims } var ( keyOnce sync.Once hsKeys map[string][]byte rsaPriv *rsa.PrivateKey rsaPub *rsa.PublicKey rsaKid string issuerVal string ) func loadKeys() { hsKeys = map[string][]byte{DefaultKid: []byte(legacySecret)} if s, _ := beego.AppConfig.String("jwt_secret"); strings.TrimSpace(s) != "" { hsKeys[DefaultKid] = []byte(strings.TrimSpace(s)) } if s, _ := beego.AppConfig.String("jwt_secrets"); strings.TrimSpace(s) != "" { for _, item := range strings.Split(s, ",") { kv := strings.SplitN(strings.TrimSpace(item), ":", 2) if len(kv) == 2 && strings.TrimSpace(kv[0]) != "" && strings.TrimSpace(kv[1]) != "" { hsKeys[strings.TrimSpace(kv[0])] = []byte(strings.TrimSpace(kv[1])) } } } privPEM := readKeyConf("jwt_rsa_private_key", "jwt_rsa_private_key_file") pubPEM := readKeyConf("jwt_rsa_public_key", "jwt_rsa_public_key_file") if privPEM != "" { if k, err := jwt.ParseRSAPrivateKeyFromPEM([]byte(privPEM)); err == nil { rsaPriv = k rsaPub = &k.PublicKey } } if pubPEM != "" { if k, err := jwt.ParseRSAPublicKeyFromPEM([]byte(pubPEM)); err == nil { rsaPub = k } } if rsaKid == "" { rsaKid, _ = beego.AppConfig.String("jwt_rsa_kid") } if rsaKid == "" { rsaKid = "rsa-1" } issuerVal, _ = beego.AppConfig.String("jwt_issuer") } func readKeyConf(inlineKey, fileKey string) string { if v, _ := beego.AppConfig.String(inlineKey); strings.TrimSpace(v) != "" { return strings.ReplaceAll(strings.TrimSpace(v), `\n`, "\n") } if p, _ := beego.AppConfig.String(fileKey); strings.TrimSpace(p) != "" { if b, err := os.ReadFile(strings.TrimSpace(p)); err == nil { return string(b) } } return "" } func ensureKeys() { keyOnce.Do(loadKeys) } func keyFunc(token *jwt.Token) (interface{}, error) { ensureKeys() kid, _ := token.Header["kid"].(string) switch token.Method.Alg() { case AlgHS256: if sec, ok := hsKeys[kid]; ok && kid != "" { return sec, nil } return hsKeys[DefaultKid], nil case AlgRS256: if rsaPub == nil { return nil, errors.New("服务端未配置 RS256 公钥") } return rsaPub, nil } return nil, fmt.Errorf("unsupported signing method: %v", token.Header["alg"]) } type TokenOptions struct { Alg string UserID int Username string TenantID int UserType string ClientID string Sid string Scope string Amr string Subject string Audience []string Jti string Events map[string]interface{} TTL time.Duration Kid string } func SignToken(opt TokenOptions) (string, error) { ensureKeys() alg := strings.ToUpper(strings.TrimSpace(opt.Alg)) if alg == "" { alg = AlgRS256 } if alg == AlgRS256 && rsaPriv == nil { alg = AlgHS256 } ttl := opt.TTL if ttl <= 0 { ttl = 30 * time.Minute } now := time.Now() claims := &Claims{ UserID: opt.UserID, Username: opt.Username, TenantId: opt.TenantID, UserType: opt.UserType, ClientID: opt.ClientID, Sid: opt.Sid, Scope: opt.Scope, Amr: opt.Amr, Events: opt.Events, RegisteredClaims: jwt.RegisteredClaims{ ID: opt.Jti, Subject: opt.Subject, Audience: opt.Audience, ExpiresAt: jwt.NewNumericDate(now.Add(ttl)), IssuedAt: jwt.NewNumericDate(now), NotBefore: jwt.NewNumericDate(now), }, } if issuerVal != "" { claims.Issuer = issuerVal } if opt.Subject == "" && opt.UserID > 0 { claims.Subject = fmt.Sprintf("%d", opt.UserID) } var method jwt.SigningMethod switch alg { case AlgRS256: method = jwt.SigningMethodRS256 default: method = jwt.SigningMethodHS256 } token := jwt.NewWithClaims(method, claims) kid := strings.TrimSpace(opt.Kid) if kid == "" && alg == AlgRS256 { kid = rsaKid } if kid != "" { token.Header["kid"] = kid } var key interface{} if alg == AlgRS256 { key = rsaPriv } else { kidToUse := kid if kidToUse == "" { kidToUse = DefaultKid } if sec, ok := hsKeys[kidToUse]; ok { key = sec } else { key = hsKeys[DefaultKid] } } return token.SignedString(key) } func GenerateToken(userID int, username string, tenantId int, userType string) (string, error) { ttl := 24 * time.Hour ensureKeys() now := time.Now() claims := &Claims{ UserID: userID, Username: username, TenantId: tenantId, UserType: userType, RegisteredClaims: jwt.RegisteredClaims{ ExpiresAt: jwt.NewNumericDate(now.Add(ttl)), IssuedAt: jwt.NewNumericDate(now), NotBefore: jwt.NewNumericDate(now), }, } if issuerVal != "" { claims.Issuer = issuerVal } token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims) return token.SignedString(hsKeys[DefaultKid]) } func ParseToken(tokenString string) (*Claims, error) { claims := &Claims{} _, err := jwt.ParseWithClaims(tokenString, claims, keyFunc, jwt.WithValidMethods([]string{AlgHS256, AlgRS256})) if err != nil { return nil, err } return claims, nil } func ParseTokenRaw(tokenString string) (*Claims, error) { claims := &Claims{} parser := jwt.NewParser(jwt.WithValidMethods([]string{AlgHS256, AlgRS256}), jwt.WithoutClaimsValidation()) if _, err := parser.ParseWithClaims(tokenString, claims, keyFunc); err != nil { return nil, err } return claims, nil } func Issuer() string { ensureKeys() return issuerVal } type JWK struct { Kty string `json:"kty"` Use string `json:"use"` Alg string `json:"alg"` Kid string `json:"kid"` N string `json:"n"` E string `json:"e"` } func JWKS() []JWK { ensureKeys() if rsaPub == nil || rsaPub.N == nil { return nil } return []JWK{{ Kty: "RSA", Use: "sig", Alg: AlgRS256, Kid: rsaKid, N: base64.RawURLEncoding.EncodeToString(rsaPub.N.Bytes()), E: base64.RawURLEncoding.EncodeToString(big.NewInt(int64(rsaPub.E)).Bytes()), }} } func HasRSA() bool { ensureKeys() return rsaPriv != nil && rsaPub != nil } func Kid() string { ensureKeys() return rsaKid }