248 lines
5.9 KiB
Go
248 lines
5.9 KiB
Go
package auth
|
|
|
|
import (
|
|
"crypto/sha256"
|
|
"encoding/hex"
|
|
"errors"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/google/uuid"
|
|
|
|
"server/models"
|
|
"server/pkg/jwtutil"
|
|
)
|
|
|
|
var (
|
|
ErrSessionLimitExceeded = errors.New("同时在线设备数已达上限")
|
|
ErrSessionRevoked = errors.New("会话已失效,请重新登录")
|
|
ErrSessionExpired = errors.New("会话已过期,请重新登录")
|
|
ErrRefreshTokenInvalid = errors.New("刷新令牌无效或已过期")
|
|
ErrRefreshTokenReused = errors.New("刷新令牌已被使用,疑似重放攻击,已吊销该登录")
|
|
)
|
|
|
|
type TokenPair struct {
|
|
AccessToken string `json:"access_token"`
|
|
RefreshToken string `json:"refresh_token"`
|
|
TokenType string `json:"token_type"`
|
|
ExpiresIn int `json:"expires_in"`
|
|
Sid string `json:"sid"`
|
|
}
|
|
|
|
type TokenIssue struct {
|
|
IdentityID uint64
|
|
Tid uint64
|
|
ClientID string
|
|
Sid string
|
|
Username string
|
|
UserType string
|
|
Amr string
|
|
AccessTTL int
|
|
RefreshTTL int
|
|
}
|
|
|
|
func IssueTokens(opt TokenIssue) (*TokenPair, error) {
|
|
accessTTL := opt.AccessTTL
|
|
if accessTTL <= 0 {
|
|
accessTTL = 1800
|
|
}
|
|
refreshTTL := opt.RefreshTTL
|
|
if refreshTTL <= 0 {
|
|
refreshTTL = 2592000
|
|
}
|
|
|
|
userID := int(opt.IdentityID)
|
|
|
|
userType := opt.UserType
|
|
if userType == "" {
|
|
userType = "backend"
|
|
if opt.ClientID == "yz-uniapp" || opt.ClientID == "yz-miniapp" {
|
|
userType = "app"
|
|
}
|
|
}
|
|
|
|
jti := uuid.NewString()
|
|
access, err := jwtutil.SignToken(jwtutil.TokenOptions{
|
|
Alg: jwtutil.AlgRS256,
|
|
UserID: userID,
|
|
Username: opt.Username,
|
|
TenantID: int(opt.Tid),
|
|
UserType: userType,
|
|
ClientID: opt.ClientID,
|
|
Sid: opt.Sid,
|
|
Amr: opt.Amr,
|
|
Subject: strconv.FormatUint(opt.IdentityID, 10),
|
|
Audience: []string{opt.ClientID},
|
|
Jti: jti,
|
|
TTL: time.Duration(accessTTL) * time.Second,
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
plain, err := randomToken(32)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
family := uuid.NewString()
|
|
now := time.Now()
|
|
rt := &models.AuthRefreshToken{
|
|
TokenHash: hashToken(plain),
|
|
IdentityID: opt.IdentityID,
|
|
Tid: opt.Tid,
|
|
ClientID: opt.ClientID,
|
|
Sid: opt.Sid,
|
|
FamilyID: family,
|
|
ExpiresAt: now.Add(time.Duration(refreshTTL) * time.Second),
|
|
}
|
|
if _, err := models.Orm.Insert(rt); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &TokenPair{
|
|
AccessToken: access,
|
|
RefreshToken: plain,
|
|
TokenType: "Bearer",
|
|
ExpiresIn: accessTTL,
|
|
Sid: opt.Sid,
|
|
}, nil
|
|
}
|
|
|
|
func RefreshTokens(plain, clientID string) (*TokenPair, error) {
|
|
h := hashToken(plain)
|
|
var rt models.AuthRefreshToken
|
|
if err := models.Orm.QueryTable(new(models.AuthRefreshToken)).Filter("token_hash", h).One(&rt); err != nil {
|
|
return nil, ErrRefreshTokenInvalid
|
|
}
|
|
if rt.ClientID != "" && clientID != "" && rt.ClientID != clientID {
|
|
return nil, ErrRefreshTokenInvalid
|
|
}
|
|
if rt.Revoked != 0 || rt.ExpiresAt.Before(time.Now()) {
|
|
return nil, ErrRefreshTokenInvalid
|
|
}
|
|
if rt.Used != 0 {
|
|
_, _ = models.Orm.QueryTable(new(models.AuthRefreshToken)).
|
|
Filter("family_id", rt.FamilyID).
|
|
Update(map[string]interface{}{"revoked": 1})
|
|
_ = RevokeSession(rt.Sid, models.RevokeReasonAdmin)
|
|
return nil, ErrRefreshTokenReused
|
|
}
|
|
|
|
_, _ = models.Orm.QueryTable(new(models.AuthRefreshToken)).
|
|
Filter("id", rt.ID).
|
|
Update(map[string]interface{}{"used": 1})
|
|
|
|
s, err := GetSession(rt.Sid)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
_ = TouchSession(rt.Sid)
|
|
|
|
pair, err := IssueTokens(TokenIssue{
|
|
IdentityID: rt.IdentityID,
|
|
Tid: s.Tid,
|
|
ClientID: rt.ClientID,
|
|
Sid: rt.Sid,
|
|
Amr: derefStr(s.Amr),
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if _, err := models.Orm.QueryTable(new(models.AuthRefreshToken)).
|
|
Filter("token_hash", hashToken(pair.RefreshToken)).
|
|
Update(map[string]interface{}{"family_id": rt.FamilyID, "rotated_from": h}); err != nil {
|
|
return nil, err
|
|
}
|
|
return pair, nil
|
|
}
|
|
|
|
func FindLegacyUID(tid, identityID uint64) uint64 {
|
|
if tid == 0 || identityID == 0 {
|
|
return 0
|
|
}
|
|
var bind models.AuthTenantUser
|
|
if err := models.Orm.QueryTable(new(models.AuthTenantUser)).
|
|
Filter("tid", tid).
|
|
Filter("identity_id", identityID).
|
|
Filter("delete_time__isnull", true).
|
|
One(&bind); err != nil {
|
|
return 0
|
|
}
|
|
|
|
qs := models.Orm.QueryTable(new(models.SystemTenantUser)).Filter("tid", tid)
|
|
match := func(field string, value *string) uint64 {
|
|
if value == nil || strings.TrimSpace(*value) == "" {
|
|
return 0
|
|
}
|
|
var row models.SystemTenantUser
|
|
if err := qs.Filter(field, strings.TrimSpace(*value)).
|
|
Filter("delete_time__isnull", true).
|
|
One(&row); err == nil {
|
|
return row.Uid
|
|
}
|
|
return 0
|
|
}
|
|
if uid := match("account", bind.Account); uid > 0 {
|
|
return uid
|
|
}
|
|
if uid := match("phone", bind.Phone); uid > 0 {
|
|
return uid
|
|
}
|
|
return match("email", bind.Email)
|
|
}
|
|
|
|
func RevokeTokenPair(plain, accessToken, reason string) error {
|
|
if plain != "" {
|
|
_, _ = models.Orm.QueryTable(new(models.AuthRefreshToken)).
|
|
Filter("token_hash", hashToken(plain)).
|
|
Update(map[string]interface{}{"revoked": 1})
|
|
}
|
|
if accessToken != "" {
|
|
if claims, err := jwtutil.ParseTokenRaw(accessToken); err == nil {
|
|
_ = Blacklist(claims.ID, claims.Sid, reason, time.Unix(claims.ExpiresAt.Unix(), 0))
|
|
if claims.Sid != "" {
|
|
_ = RevokeSession(claims.Sid, reason)
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func Blacklist(jti, sid, reason string, expiresAt time.Time) error {
|
|
if jti == "" {
|
|
return nil
|
|
}
|
|
item := &models.AuthTokenBlacklist{
|
|
Jti: jti,
|
|
ExpiresAt: expiresAt,
|
|
}
|
|
if sid != "" {
|
|
item.Sid = &sid
|
|
}
|
|
if reason != "" {
|
|
item.Reason = &reason
|
|
}
|
|
_, err := models.Orm.InsertOrUpdate(item, "jti")
|
|
return err
|
|
}
|
|
|
|
func IsBlacklisted(jti string) bool {
|
|
if jti == "" {
|
|
return false
|
|
}
|
|
return models.Orm.QueryTable(new(models.AuthTokenBlacklist)).Filter("jti", jti).Exist()
|
|
}
|
|
|
|
func hashToken(plain string) string {
|
|
sum := sha256.Sum256([]byte(plain))
|
|
return hex.EncodeToString(sum[:])
|
|
}
|
|
|
|
func derefStr(p *string) string {
|
|
if p == nil {
|
|
return ""
|
|
}
|
|
return *p
|
|
}
|