forked from mtusi2026/mtusi2026lab4
103 lines
2.6 KiB
Go
103 lines
2.6 KiB
Go
package chat
|
|
|
|
import (
|
|
"context"
|
|
"crypto/rand"
|
|
"crypto/sha256"
|
|
"encoding/base64"
|
|
"encoding/hex"
|
|
"strings"
|
|
"time"
|
|
"unicode/utf8"
|
|
|
|
"gitflic.ru/akselbant/mtusi2026lab1-fork/internal/pkg/domain"
|
|
"gitflic.ru/akselbant/mtusi2026lab1-fork/internal/pkg/password"
|
|
)
|
|
|
|
type Sessions interface {
|
|
Put(context.Context, string, domain.Session) error
|
|
Get(context.Context, string) (domain.Session, bool, error)
|
|
Delete(context.Context, string) (bool, error)
|
|
Ready(context.Context) error
|
|
}
|
|
|
|
func validPassword(value string) bool {
|
|
n := utf8.RuneCountInString(value)
|
|
return utf8.ValidString(value) && n >= 12 && n <= 128 && strings.TrimSpace(value) != ""
|
|
}
|
|
|
|
func tokenKey(token string) string {
|
|
sum := sha256.Sum256([]byte(token))
|
|
return hex.EncodeToString(sum[:])
|
|
}
|
|
|
|
func (u *UseCase) Authenticate(ctx context.Context, token string) (domain.User, error) {
|
|
decoded, err := base64.RawURLEncoding.DecodeString(token)
|
|
if err != nil || len(decoded) != 32 {
|
|
return domain.User{}, unauthorized()
|
|
}
|
|
session, exists, err := u.sessions.Get(ctx, tokenKey(token))
|
|
if err != nil {
|
|
return domain.User{}, err
|
|
}
|
|
if !exists || !time.Now().Before(session.ExpiresAt) {
|
|
return domain.User{}, unauthorized()
|
|
}
|
|
user, exists, err := u.repository.User(ctx, session.UserID)
|
|
if err != nil {
|
|
return domain.User{}, err
|
|
}
|
|
if !exists {
|
|
return domain.User{}, unauthorized()
|
|
}
|
|
return user, nil
|
|
}
|
|
|
|
func (u *UseCase) CreateSession(ctx context.Context, username, secret string) (domain.Login, error) {
|
|
if !validUsername(username) || !validPassword(secret) {
|
|
return domain.Login{}, unauthorized()
|
|
}
|
|
user, hash, exists, err := u.repository.UserByUsername(ctx, username)
|
|
if err != nil {
|
|
return domain.Login{}, err
|
|
}
|
|
if !exists {
|
|
hash = password.DummyHash
|
|
}
|
|
valid, err := password.Verify(ctx, secret, hash)
|
|
if err != nil {
|
|
return domain.Login{}, err
|
|
}
|
|
if !valid || !exists {
|
|
return domain.Login{}, unauthorized()
|
|
}
|
|
var raw [32]byte
|
|
if _, err = rand.Read(raw[:]); err != nil {
|
|
return domain.Login{}, err
|
|
}
|
|
token := base64.RawURLEncoding.EncodeToString(raw[:])
|
|
expires := time.Now().UTC().Add(u.sessionTTL)
|
|
if err = u.sessions.Put(ctx, tokenKey(token), domain.Session{UserID: user.ID, ExpiresAt: expires}); err != nil {
|
|
return domain.Login{}, err
|
|
}
|
|
return domain.Login{Token: token, ExpiresAt: expires, User: user}, nil
|
|
}
|
|
|
|
func (u *UseCase) DeleteSession(ctx context.Context, token string) error {
|
|
deleted, err := u.sessions.Delete(ctx, tokenKey(token))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if !deleted {
|
|
return unauthorized()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (u *UseCase) Ready(ctx context.Context) error {
|
|
if err := u.repository.Ready(ctx); err != nil {
|
|
return err
|
|
}
|
|
return u.sessions.Ready(ctx)
|
|
}
|