264 lines
5.9 KiB
Go
264 lines
5.9 KiB
Go
package auth
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"errors"
|
|
"fmt"
|
|
"time"
|
|
|
|
"mediarr/database"
|
|
"mediarr/ident"
|
|
"mediarr/identity"
|
|
)
|
|
|
|
const (
|
|
maxFailedAttempts = 5
|
|
lockDuration = 15 * time.Minute
|
|
)
|
|
|
|
type CreateUserParams struct {
|
|
Login string
|
|
Password string
|
|
Role string
|
|
}
|
|
|
|
func (s *Service) CreateUser(ctx context.Context, params CreateUserParams) (*AuthenticatedUser, error) {
|
|
display, key, err := normalizeLogin(params.Login)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if err := validatePassword(params.Password); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
role := params.Role
|
|
if role == "" {
|
|
role = identity.RoleMember
|
|
}
|
|
|
|
groupName, err := identity.GroupNameForRole(role)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
group, err := s.db.Queries.GetPrincipalByNameAndKind(ctx, database.GetPrincipalByNameAndKindParams{
|
|
Kind: identity.KindGroup,
|
|
Name: groupName,
|
|
})
|
|
if err != nil {
|
|
if errors.Is(err, sql.ErrNoRows) {
|
|
return nil, fmt.Errorf("%w: %s", identity.ErrGroupNotFound, groupName)
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
passwordHash, err := HashPassword(params.Password)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
userID, err := ident.NewV7()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
now := time.Now().UnixMilli()
|
|
|
|
err = s.withTx(ctx, func(q *database.Queries) error {
|
|
if _, err := q.CreatePrincipal(ctx, database.CreatePrincipalParams{
|
|
ID: userID,
|
|
Kind: identity.KindUser,
|
|
Name: display,
|
|
Status: identity.StatusActive,
|
|
CreatedAt: now,
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
|
|
if _, err := q.CreateAccount(ctx, database.CreateAccountParams{
|
|
PrincipalID: userID,
|
|
Login: display,
|
|
LoginKey: key,
|
|
PasswordHash: sql.NullString{
|
|
String: passwordHash,
|
|
Valid: true,
|
|
},
|
|
PasswordChangedAt: sql.NullInt64{
|
|
Int64: now,
|
|
Valid: true,
|
|
},
|
|
MustChangePassword: 0,
|
|
State: AccountStateActive,
|
|
FailedAttempts: 0,
|
|
CreatedAt: now,
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
|
|
_, err := q.CreateMembership(ctx, database.CreateMembershipParams{
|
|
GroupID: group.ID,
|
|
MemberID: userID,
|
|
Role: identity.RoleMember,
|
|
CreatedAt: now,
|
|
})
|
|
return err
|
|
})
|
|
if err != nil {
|
|
if isUniqueViolation(err) {
|
|
return nil, fmt.Errorf("%w: %s", ErrLoginTaken, display)
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
return s.loadAuthenticatedUser(ctx, userID)
|
|
}
|
|
|
|
func (s *Service) Authenticate(ctx context.Context, login, password string) (*AuthenticatedUser, error) {
|
|
_, key, err := normalizeLogin(login)
|
|
if err != nil {
|
|
return nil, ErrInvalidCredentials
|
|
}
|
|
|
|
account, err := s.db.Queries.GetAccountByLoginKey(ctx, key)
|
|
if err != nil {
|
|
if errors.Is(err, sql.ErrNoRows) {
|
|
return nil, ErrInvalidCredentials
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
principal, err := s.db.Queries.GetPrincipal(ctx, account.PrincipalID)
|
|
if err != nil {
|
|
if errors.Is(err, sql.ErrNoRows) {
|
|
return nil, ErrInvalidCredentials
|
|
}
|
|
return nil, err
|
|
}
|
|
if principal.Status != identity.StatusActive {
|
|
return nil, ErrInvalidCredentials
|
|
}
|
|
|
|
now := time.Now().UnixMilli()
|
|
|
|
switch account.State {
|
|
case AccountStateDisabled:
|
|
return nil, ErrAccountDisabled
|
|
case AccountStateLocked:
|
|
if !account.LockedUntil.Valid || account.LockedUntil.Int64 > now {
|
|
return nil, ErrAccountLocked
|
|
}
|
|
if _, err := s.db.WriteQueries.UnlockAccount(ctx, account.PrincipalID); err != nil {
|
|
return nil, err
|
|
}
|
|
account.State = AccountStateActive
|
|
account.FailedAttempts = 0
|
|
account.LockedUntil = sql.NullInt64{}
|
|
}
|
|
|
|
if !account.PasswordHash.Valid {
|
|
return nil, ErrInvalidCredentials
|
|
}
|
|
|
|
valid, err := VerifyPassword(password, account.PasswordHash.String)
|
|
if err != nil {
|
|
return nil, ErrInvalidCredentials
|
|
}
|
|
|
|
if !valid {
|
|
updated, err := s.db.WriteQueries.RegisterFailedLogin(ctx, database.RegisterFailedLoginParams{
|
|
MaxAttempts: maxFailedAttempts,
|
|
LockedUntil: sql.NullInt64{
|
|
Int64: now + lockDuration.Milliseconds(),
|
|
Valid: true,
|
|
},
|
|
PrincipalID: account.PrincipalID,
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if updated.State == AccountStateLocked {
|
|
return nil, ErrAccountLocked
|
|
}
|
|
return nil, ErrInvalidCredentials
|
|
}
|
|
|
|
if _, err := s.db.WriteQueries.RecordLogin(ctx, database.RecordLoginParams{
|
|
LastLoginAt: sql.NullInt64{
|
|
Int64: now,
|
|
Valid: true,
|
|
},
|
|
PrincipalID: account.PrincipalID,
|
|
}); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return s.loadAuthenticatedUser(ctx, account.PrincipalID)
|
|
}
|
|
|
|
func (s *Service) SetPassword(ctx context.Context, principalID ident.UUID, password string) error {
|
|
if err := validatePassword(password); err != nil {
|
|
return err
|
|
}
|
|
|
|
passwordHash, err := HashPassword(password)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
now := time.Now().UnixMilli()
|
|
|
|
_, err = s.db.WriteQueries.UpdatePassword(ctx, database.UpdatePasswordParams{
|
|
PasswordHash: sql.NullString{
|
|
String: passwordHash,
|
|
Valid: true,
|
|
},
|
|
PasswordChangedAt: sql.NullInt64{
|
|
Int64: now,
|
|
Valid: true,
|
|
},
|
|
PrincipalID: principalID,
|
|
})
|
|
return err
|
|
}
|
|
|
|
func (s *Service) loadAuthenticatedUser(ctx context.Context, id ident.UUID) (*AuthenticatedUser, error) {
|
|
principal, err := s.identity.GetPrincipal(ctx, id)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
account, err := s.db.Queries.GetAccount(ctx, id)
|
|
switch {
|
|
case err == nil:
|
|
return &AuthenticatedUser{
|
|
Principal: *principal,
|
|
Account: accountFromDB(account),
|
|
}, nil
|
|
case errors.Is(err, sql.ErrNoRows):
|
|
return &AuthenticatedUser{
|
|
Principal: *principal,
|
|
Account: Account{
|
|
PrincipalID: id,
|
|
Login: principal.Name,
|
|
State: AccountStateActive,
|
|
},
|
|
}, nil
|
|
default:
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
func accountFromDB(account database.Account) Account {
|
|
return Account{
|
|
PrincipalID: account.PrincipalID,
|
|
Login: account.Login,
|
|
State: account.State,
|
|
MustChangePassword: account.MustChangePassword != 0,
|
|
FailedAttempts: account.FailedAttempts,
|
|
LockedUntil: account.LockedUntil,
|
|
LastLoginAt: account.LastLoginAt,
|
|
CreatedAt: account.CreatedAt,
|
|
}
|
|
}
|