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 }