version 1
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

This commit is contained in:
Ivan Rezchikov
2026-09-18 00:45:51 +03:00
commit 628dd6384b
149 changed files with 11478 additions and 0 deletions
+151
View File
@@ -0,0 +1,151 @@
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
}