Build and Deploy / test-backend (push) Successful in 1m11s
Build and Deploy / lint-frontend (push) Successful in 21s
Build and Deploy / build-backend (push) Successful in 58s
Build and Deploy / deploy (push) Canceled after 0s
Build and Deploy / build-frontend (push) Canceled after 5m38s
151 lines
3.5 KiB
Go
151 lines
3.5 KiB
Go
package service
|
|
|
|
import (
|
|
"context"
|
|
"crypto/hmac"
|
|
"crypto/rand"
|
|
"crypto/sha256"
|
|
"encoding/base64"
|
|
"encoding/hex"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/google/uuid"
|
|
"github.com/redis/go-redis/v9"
|
|
)
|
|
|
|
// SessionService issues signed, expiring session JWTs and keeps an index in
|
|
// Redis so that sessions can be revoked (e.g. on logout).
|
|
type SessionService struct {
|
|
redis *redis.Client
|
|
secret []byte
|
|
ttl time.Duration
|
|
}
|
|
|
|
func NewSessionService(redis *redis.Client, secret string) *SessionService {
|
|
return &SessionService{redis: redis, secret: []byte(secret), ttl: 30 * 24 * time.Hour}
|
|
}
|
|
|
|
type sessionClaims struct {
|
|
Sub string `json:"sub"`
|
|
JTI string `json:"jti"`
|
|
Iat int64 `json:"iat"`
|
|
Exp int64 `json:"exp"`
|
|
}
|
|
|
|
func (s *SessionService) Create(ctx context.Context, userID uuid.UUID) (string, error) {
|
|
jtiBytes := make([]byte, 16)
|
|
if _, err := rand.Read(jtiBytes); err != nil {
|
|
return "", err
|
|
}
|
|
jti := hex.EncodeToString(jtiBytes)
|
|
|
|
now := time.Now().UTC()
|
|
claims := sessionClaims{
|
|
Sub: userID.String(),
|
|
JTI: jti,
|
|
Iat: now.Unix(),
|
|
Exp: now.Add(s.ttl).Unix(),
|
|
}
|
|
|
|
token, err := signToken(claims, s.secret)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
if err := s.redis.Set(ctx, "session:"+jti, userID.String(), s.ttl).Err(); err != nil {
|
|
return "", err
|
|
}
|
|
|
|
return token, nil
|
|
}
|
|
|
|
func (s *SessionService) UserID(ctx context.Context, token string) (string, error) {
|
|
claims, err := parseToken(token, s.secret)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
stored, err := s.redis.Get(ctx, "session:"+claims.JTI).Result()
|
|
if err != nil {
|
|
if errors.Is(err, redis.Nil) {
|
|
return "", fmt.Errorf("session revoked or expired")
|
|
}
|
|
return "", err
|
|
}
|
|
|
|
if stored != claims.Sub {
|
|
return "", fmt.Errorf("session token mismatch")
|
|
}
|
|
|
|
return stored, nil
|
|
}
|
|
|
|
func (s *SessionService) Revoke(ctx context.Context, token string) error {
|
|
claims, err := parseToken(token, s.secret)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if err := s.redis.Del(ctx, "session:"+claims.JTI).Err(); err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func signToken(claims sessionClaims, secret []byte) (string, error) {
|
|
header := base64.RawURLEncoding.EncodeToString([]byte(`{"alg":"HS256","typ":"JWT"}`))
|
|
payload, err := json.Marshal(claims)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
payloadB64 := base64.RawURLEncoding.EncodeToString(payload)
|
|
|
|
signingInput := header + "." + payloadB64
|
|
mac := hmac.New(sha256.New, secret)
|
|
mac.Write([]byte(signingInput))
|
|
signature := base64.RawURLEncoding.EncodeToString(mac.Sum(nil))
|
|
|
|
return signingInput + "." + signature, nil
|
|
}
|
|
|
|
func parseToken(token string, secret []byte) (*sessionClaims, error) {
|
|
parts := strings.Split(token, ".")
|
|
if len(parts) != 3 {
|
|
return nil, errors.New("malformed token")
|
|
}
|
|
|
|
signature, err := base64.RawURLEncoding.DecodeString(parts[2])
|
|
if err != nil {
|
|
return nil, fmt.Errorf("invalid token signature encoding: %w", err)
|
|
}
|
|
|
|
mac := hmac.New(sha256.New, secret)
|
|
mac.Write([]byte(parts[0] + "." + parts[1]))
|
|
if !hmac.Equal(signature, mac.Sum(nil)) {
|
|
return nil, errors.New("invalid token signature")
|
|
}
|
|
|
|
payload, err := base64.RawURLEncoding.DecodeString(parts[1])
|
|
if err != nil {
|
|
return nil, fmt.Errorf("invalid token payload encoding: %w", err)
|
|
}
|
|
|
|
var claims sessionClaims
|
|
if err := json.Unmarshal(payload, &claims); err != nil {
|
|
return nil, fmt.Errorf("invalid token payload: %w", err)
|
|
}
|
|
|
|
if claims.Sub == "" || claims.JTI == "" {
|
|
return nil, errors.New("token missing claims")
|
|
}
|
|
if claims.Exp < time.Now().UTC().Unix() {
|
|
return nil, errors.New("token expired")
|
|
}
|
|
|
|
return &claims, nil
|
|
} |