298 lines
6.6 KiB
Go
298 lines
6.6 KiB
Go
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
|
|
}
|