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: "active", 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: "active", 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 != "active" { return nil, ErrInvalidCredentials } now := time.Now().UnixMilli() switch account.State { case "disabled": return nil, ErrAccountDisabled case "locked": 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 = "active" 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 == "locked" { 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: "active", }, }, 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, } }