141 lines
2.8 KiB
Go
141 lines
2.8 KiB
Go
package identity
|
|
|
|
import (
|
|
"errors"
|
|
"net/http"
|
|
"strings"
|
|
|
|
"server/pkg/jwtutil"
|
|
|
|
"github.com/golang-jwt/jwt/v5"
|
|
)
|
|
|
|
type End string
|
|
|
|
const (
|
|
EndPlatform End = "platform"
|
|
EndBackend End = "backend"
|
|
EndApp End = "app"
|
|
EndGuest End = "guest"
|
|
)
|
|
|
|
var (
|
|
ErrNoToken = errors.New("未提供认证信息")
|
|
ErrBadFormat = errors.New("认证信息格式错误")
|
|
ErrExpired = errors.New("token已过期")
|
|
ErrInvalid = errors.New("无效的token")
|
|
ErrWrongEnd = errors.New("无权访问")
|
|
)
|
|
|
|
type Identity struct {
|
|
UserID int
|
|
Username string
|
|
TenantID uint64
|
|
End End
|
|
ClientID string
|
|
Sid string
|
|
}
|
|
|
|
func normalizeEnd(userType string) End {
|
|
if userType == "tenant" {
|
|
return EndBackend
|
|
}
|
|
return End(userType)
|
|
}
|
|
|
|
func Claims(auth string, allowed ...End) (*jwtutil.Claims, error) {
|
|
auth = strings.TrimSpace(auth)
|
|
if auth == "" {
|
|
return nil, ErrNoToken
|
|
}
|
|
parts := strings.SplitN(auth, " ", 2)
|
|
if len(parts) != 2 || !strings.EqualFold(parts[0], "Bearer") {
|
|
return nil, ErrBadFormat
|
|
}
|
|
|
|
claims, err := jwtutil.ParseToken(parts[1])
|
|
if err != nil {
|
|
return nil, classify(err)
|
|
}
|
|
|
|
end := normalizeEnd(claims.UserType)
|
|
granted := false
|
|
for _, a := range allowed {
|
|
if a == end {
|
|
granted = true
|
|
break
|
|
}
|
|
}
|
|
if !granted {
|
|
return nil, ErrWrongEnd
|
|
}
|
|
return claims, nil
|
|
}
|
|
|
|
func IsGuest(claims *jwtutil.Claims) bool {
|
|
return claims != nil && claims.UserType == string(EndGuest)
|
|
}
|
|
|
|
func PathEnd(path string) (End, bool) {
|
|
p := strings.ToLower(path)
|
|
switch {
|
|
case strings.HasPrefix(p, "/platform/"):
|
|
return EndPlatform, true
|
|
case strings.HasPrefix(p, "/backend/"):
|
|
return EndBackend, true
|
|
case strings.HasPrefix(p, "/api/"), strings.HasPrefix(p, "/app/"):
|
|
return EndApp, true
|
|
}
|
|
return "", false
|
|
}
|
|
|
|
func ClaimsByPath(auth, path string) (*jwtutil.Claims, error) {
|
|
if end, ok := PathEnd(path); ok {
|
|
return Claims(auth, end)
|
|
}
|
|
return Claims(auth, EndPlatform, EndBackend, EndApp)
|
|
}
|
|
|
|
func Require(r *http.Request, allowed ...End) (*Identity, error) {
|
|
if r == nil {
|
|
return nil, ErrNoToken
|
|
}
|
|
claims, err := Claims(r.Header.Get("Authorization"), allowed...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
tid := claims.TenantId
|
|
if tid < 0 {
|
|
tid = 0
|
|
}
|
|
return &Identity{
|
|
UserID: claims.UserID,
|
|
Username: claims.Username,
|
|
TenantID: uint64(tid),
|
|
End: normalizeEnd(claims.UserType),
|
|
ClientID: claims.ClientID,
|
|
Sid: claims.Sid,
|
|
}, nil
|
|
}
|
|
|
|
func classify(err error) error {
|
|
if errors.Is(err, jwt.ErrTokenExpired) || strings.Contains(err.Error(), "expired") {
|
|
return ErrExpired
|
|
}
|
|
return ErrInvalid
|
|
}
|
|
|
|
func Status(err error) int {
|
|
if errors.Is(err, ErrWrongEnd) {
|
|
return http.StatusForbidden
|
|
}
|
|
return http.StatusUnauthorized
|
|
}
|
|
|
|
func IsAuth(err error) bool {
|
|
return errors.Is(err, ErrNoToken) || errors.Is(err, ErrBadFormat) ||
|
|
errors.Is(err, ErrExpired) || errors.Is(err, ErrInvalid) ||
|
|
errors.Is(err, ErrWrongEnd)
|
|
}
|