106 lines
2.5 KiB
Go
106 lines
2.5 KiB
Go
package service
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"time"
|
|
|
|
"mtusi2026-messenger/internal/credentials"
|
|
"mtusi2026-messenger/internal/db"
|
|
"mtusi2026-messenger/internal/model"
|
|
"mtusi2026-messenger/internal/postgres"
|
|
|
|
"github.com/google/uuid"
|
|
)
|
|
|
|
var (
|
|
ErrInvalidCredentials = errors.New("invalid credentials")
|
|
ErrUnauthorized = errors.New("unauthorized")
|
|
)
|
|
|
|
type authQueries interface {
|
|
CreateSession(ctx context.Context, arg db.CreateSessionParams) error
|
|
DeleteSession(ctx context.Context, tokenHash string) (int64, error)
|
|
GetSessionUserID(ctx context.Context, tokenHash string) (uuid.UUID, error)
|
|
GetUserByUsername(ctx context.Context, username string) (db.User, error)
|
|
}
|
|
|
|
type AuthService struct {
|
|
q authQueries
|
|
sessionTTL time.Duration
|
|
}
|
|
|
|
func NewAuthService(q authQueries, sessionTTL time.Duration) *AuthService {
|
|
return &AuthService{
|
|
q: q,
|
|
sessionTTL: sessionTTL,
|
|
}
|
|
}
|
|
|
|
var dummyHash, _ = credentials.HashPassword("dummy-password-for-timing")
|
|
|
|
func (s *AuthService) Login(ctx context.Context, username, plain string) (model.Session, error) {
|
|
user, err := s.q.GetUserByUsername(ctx, username)
|
|
if postgres.IsNotFound(err) {
|
|
_ = credentials.VerifyPassword(dummyHash, plain)
|
|
return model.Session{}, ErrInvalidCredentials
|
|
}
|
|
if err != nil {
|
|
return model.Session{}, err
|
|
}
|
|
|
|
if err := credentials.VerifyPassword(user.PasswordHash, plain); err != nil {
|
|
if errors.Is(err, credentials.ErrPasswordMismatch) {
|
|
return model.Session{}, ErrInvalidCredentials
|
|
}
|
|
return model.Session{}, err
|
|
}
|
|
|
|
token := credentials.NewToken()
|
|
expiresAt := time.Now().UTC().Add(s.sessionTTL)
|
|
|
|
err = s.q.CreateSession(ctx, db.CreateSessionParams{
|
|
TokenHash: credentials.HashToken(token),
|
|
UserID: user.ID,
|
|
ExpiresAt: expiresAt,
|
|
})
|
|
if err != nil {
|
|
return model.Session{}, err
|
|
}
|
|
|
|
return model.Session{
|
|
Token: token,
|
|
ExpiresAt: expiresAt,
|
|
User: model.User{
|
|
ID: user.ID,
|
|
Username: user.Username,
|
|
DisplayName: user.DisplayName,
|
|
CreatedAt: user.CreatedAt.UTC(),
|
|
},
|
|
}, nil
|
|
}
|
|
|
|
func (s *AuthService) Authenticate(ctx context.Context, token string) (uuid.UUID, error) {
|
|
userID, err := s.q.GetSessionUserID(ctx, credentials.HashToken(token))
|
|
if postgres.IsNotFound(err) {
|
|
return uuid.Nil, ErrUnauthorized
|
|
}
|
|
if err != nil {
|
|
return uuid.Nil, err
|
|
}
|
|
|
|
return userID, nil
|
|
}
|
|
|
|
func (s *AuthService) Logout(ctx context.Context, token string) error {
|
|
n, err := s.q.DeleteSession(ctx, credentials.HashToken(token))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if n == 0 {
|
|
return ErrUnauthorized
|
|
}
|
|
|
|
return nil
|
|
}
|