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 }