create account + create session

This commit is contained in:
venture
2026-11-14 09:35:04 +01:00
parent 7ebe8962dd
commit f7649f24ef
19 changed files with 2218 additions and 16 deletions
+19
View File
@@ -0,0 +1,19 @@
package user
import "errors"
var (
ErrInvalidCredentials = errors.New("identifiants invalides")
ErrAccountLocked = errors.New("compte verrouillé")
ErrAccountDisabled = errors.New("compte désactivé")
ErrLoginTaken = errors.New("login déjà utilisé")
ErrInvalidLogin = errors.New("login invalide")
ErrWeakPassword = errors.New("mot de passe trop faible")
ErrInvalidSession = errors.New("session invalide")
ErrInvalidRole = errors.New("rôle invalide")
ErrAlreadyMember = errors.New("membre déjà présent dans le groupe")
ErrNotMember = errors.New("membre absent du groupe")
ErrInvalidMember = errors.New("membre invalide : utilisateur ou invité attendu")
ErrInvalidGroup = errors.New("groupe invalide")
ErrGroupNotFound = errors.New("groupe introuvable")
)
+131
View File
@@ -0,0 +1,131 @@
package user
import (
"context"
"database/sql"
"errors"
"fmt"
"time"
"mediarr/database"
"mediarr/ident"
)
type Member struct {
ID ident.UUID
Name string
Kind string
Role string
}
func groupNameForRole(role string) (string, error) {
switch role {
case RoleAdmin:
return "admins", nil
case RoleMember:
return "members", nil
default:
return "", fmt.Errorf("%w: %q", ErrInvalidRole, role)
}
}
func (s *Service) AddMember(ctx context.Context, groupID, memberID ident.UUID, role string) error {
if role == "" {
role = "member"
}
if role != "member" && role != "admin" {
return fmt.Errorf("%w: %q", ErrInvalidRole, role)
}
group, err := s.db.Queries.GetPrincipal(ctx, groupID)
if err != nil {
if errors.Is(err, sql.ErrNoRows) {
return ErrGroupNotFound
}
return err
}
if group.Kind != "group" {
return fmt.Errorf("%w: %s", ErrInvalidGroup, group.Kind)
}
member, err := s.db.Queries.GetPrincipal(ctx, memberID)
if err != nil {
if errors.Is(err, sql.ErrNoRows) {
return ErrInvalidMember
}
return err
}
if member.Kind != "user" && member.Kind != "guest" {
return fmt.Errorf("%w: %s", ErrInvalidMember, member.Kind)
}
_, err = s.db.WriteQueries.CreateMembership(ctx, database.CreateMembershipParams{
GroupID: groupID,
MemberID: memberID,
Role: role,
CreatedAt: time.Now().UnixMilli(),
})
if err != nil {
if isUniqueViolation(err) {
return fmt.Errorf("%w: %s dans %s", ErrAlreadyMember, member.Name, group.Name)
}
return err
}
return nil
}
func (s *Service) RemoveMember(ctx context.Context, groupID, memberID ident.UUID) error {
_, err := s.db.Queries.GetMembership(ctx, database.GetMembershipParams{
GroupID: groupID,
MemberID: memberID,
})
if err != nil {
if errors.Is(err, sql.ErrNoRows) {
return ErrNotMember
}
return err
}
return s.db.WriteQueries.DeleteMembership(ctx, database.DeleteMembershipParams{
GroupID: groupID,
MemberID: memberID,
})
}
func (s *Service) ListGroups(ctx context.Context, memberID ident.UUID) ([]Group, error) {
rows, err := s.db.Queries.ListMemberGroupsWithRole(ctx, memberID)
if err != nil {
return nil, err
}
groups := make([]Group, 0, len(rows))
for _, row := range rows {
groups = append(groups, Group{
ID: row.ID,
Name: row.Name,
Role: row.Role,
})
}
return groups, nil
}
func (s *Service) ListGroupMembers(ctx context.Context, groupID ident.UUID) ([]Member, error) {
rows, err := s.db.Queries.ListGroupMembersWithRole(ctx, groupID)
if err != nil {
return nil, err
}
members := make([]Member, 0, len(rows))
for _, row := range rows {
members = append(members, Member{
ID: row.ID,
Name: row.Name,
Kind: row.Kind,
Role: row.Role,
})
}
return members, nil
}
+83
View File
@@ -0,0 +1,83 @@
package user
import (
"context"
"errors"
"testing"
)
func TestAddAndRemoveMember(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
created := mustCreateUser(t, service, "alice", "correct horse battery staple", RoleMember)
admins := mustGroup(t, service, "admins")
if err := service.AddMember(ctx, admins.ID, created.ID, "admin"); err != nil {
t.Fatalf("AddMember : %v", err)
}
groups, err := service.ListGroups(ctx, created.ID)
if err != nil {
t.Fatalf("ListGroups : %v", err)
}
if !hasGroup(groups, "admins") || !hasGroup(groups, "members") {
t.Fatalf("groupes = %+v, attendu admins et members", groups)
}
members, err := service.ListGroupMembers(ctx, admins.ID)
if err != nil {
t.Fatalf("ListGroupMembers : %v", err)
}
if len(members) != 1 || members[0].ID != created.ID || members[0].Role != "admin" {
t.Fatalf("membres = %+v, attendu alice admin", members)
}
if err := service.RemoveMember(ctx, admins.ID, created.ID); err != nil {
t.Fatalf("RemoveMember : %v", err)
}
if err := service.RemoveMember(ctx, admins.ID, created.ID); !errors.Is(err, ErrNotMember) {
t.Fatalf("erreur = %v, attendu ErrNotMember", err)
}
}
func TestAddMemberRejectsDuplicate(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
created := mustCreateUser(t, service, "alice", "correct horse battery staple", RoleMember)
members := mustGroup(t, service, "members")
err := service.AddMember(ctx, members.ID, created.ID, "member")
if !errors.Is(err, ErrAlreadyMember) {
t.Fatalf("erreur = %v, attendu ErrAlreadyMember", err)
}
}
func TestAddMemberRejectsInvalidMember(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
created := mustCreateUser(t, service, "alice", "correct horse battery staple", RoleMember)
members := mustGroup(t, service, "members")
err := service.AddMember(ctx, members.ID, members.ID, "member")
if !errors.Is(err, ErrInvalidMember) {
t.Fatalf("erreur = %v, attendu ErrInvalidMember", err)
}
err = service.AddMember(ctx, created.ID, created.ID, "member")
if !errors.Is(err, ErrInvalidGroup) {
t.Fatalf("erreur = %v, attendu ErrInvalidGroup", err)
}
}
func hasGroup(groups []Group, name string) bool {
for _, group := range groups {
if group.Name == name {
return true
}
}
return false
}
+56
View File
@@ -0,0 +1,56 @@
package user
import (
"context"
"testing"
"mediarr/database"
)
func newTestService(t *testing.T) *Service {
t.Helper()
t.Chdir(t.TempDir())
err, db := database.NewDatabase(database.NewDatabaseParams{})
if err != nil {
t.Fatalf("NewDatabase : %v", err)
}
t.Cleanup(func() {
if err := db.Close(); err != nil {
t.Errorf("Close : %v", err)
}
})
return NewService(*db)
}
func mustCreateUser(t *testing.T, service *Service, login, password, role string) *User {
t.Helper()
created, err := service.CreateUser(context.Background(), CreateUserParams{
Login: login,
Password: password,
Role: role,
})
if err != nil {
t.Fatalf("CreateUser(%q) : %v", login, err)
}
return created
}
func mustGroup(t *testing.T, service *Service, name string) database.Principal {
t.Helper()
group, err := service.db.Queries.GetPrincipalByNameAndKind(context.Background(), database.GetPrincipalByNameAndKindParams{
Kind: "group",
Name: name,
})
if err != nil {
t.Fatalf("groupe %q : %v", name, err)
}
return group
}
+41
View File
@@ -0,0 +1,41 @@
package user
import (
"fmt"
"strings"
"unicode"
)
const (
minPasswordLen = 8
maxPasswordLen = 1024
maxLoginLen = 255
)
func normalizeLogin(login string) (string, string, error) {
display := strings.TrimSpace(login)
if display == "" {
return "", "", fmt.Errorf("%w: vide", ErrInvalidLogin)
}
if len(display) > maxLoginLen {
return "", "", fmt.Errorf("%w: maximum %d caractères", ErrInvalidLogin, maxLoginLen)
}
if strings.IndexFunc(display, unicode.IsSpace) >= 0 {
return "", "", fmt.Errorf("%w: espaces interdits", ErrInvalidLogin)
}
if strings.ContainsRune(display, 0) {
return "", "", fmt.Errorf("%w: caractère nul interdit", ErrInvalidLogin)
}
return display, strings.ToLower(display), nil
}
func validatePassword(password string) error {
if len(password) < minPasswordLen {
return fmt.Errorf("%w: minimum %d caractères", ErrWeakPassword, minPasswordLen)
}
if len(password) > maxPasswordLen {
return fmt.Errorf("%w: maximum %d octets", ErrWeakPassword, maxPasswordLen)
}
return nil
}
+103
View File
@@ -0,0 +1,103 @@
package user
import (
"crypto/rand"
"crypto/subtle"
"encoding/base64"
"errors"
"fmt"
"strings"
"golang.org/x/crypto/argon2"
)
const (
argon2Memory uint32 = 19 * 1024
argon2Time uint32 = 2
argon2Threads uint8 = 1
argon2KeyLen uint32 = 32
argon2SaltLen = 16
)
type argon2Params struct {
memory uint32
time uint32
threads uint8
}
func HashPassword(password string) (string, error) {
if err := validatePassword(password); err != nil {
return "", err
}
salt := make([]byte, argon2SaltLen)
if _, err := rand.Read(salt); err != nil {
return "", fmt.Errorf("user: génération du sel : %w", err)
}
key := argon2.IDKey([]byte(password), salt, argon2Time, argon2Memory, argon2Threads, argon2KeyLen)
return fmt.Sprintf(
"$argon2id$v=%d$m=%d,t=%d,p=%d$%s$%s",
argon2.Version,
argon2Memory,
argon2Time,
argon2Threads,
base64.RawStdEncoding.EncodeToString(salt),
base64.RawStdEncoding.EncodeToString(key),
), nil
}
func VerifyPassword(password, encoded string) (bool, error) {
params, salt, key, err := decodePasswordHash(encoded)
if err != nil {
return false, err
}
candidate := argon2.IDKey([]byte(password), salt, params.time, params.memory, params.threads, uint32(len(key)))
return subtle.ConstantTimeCompare(candidate, key) == 1, nil
}
func decodePasswordHash(encoded string) (argon2Params, []byte, []byte, error) {
var params argon2Params
parts := strings.Split(encoded, "$")
if len(parts) != 6 || parts[0] != "" || parts[1] != "argon2id" {
return params, nil, nil, errors.New("user: hash Argon2id invalide")
}
var version int
if _, err := fmt.Sscanf(parts[2], "v=%d", &version); err != nil || version != argon2.Version {
return params, nil, nil, errors.New("user: version Argon2id invalide")
}
var memory, iterations, threads uint32
if _, err := fmt.Sscanf(parts[3], "m=%d,t=%d,p=%d", &memory, &iterations, &threads); err != nil {
return params, nil, nil, errors.New("user: paramètres Argon2id invalides")
}
if memory < 8*1024 || memory > 1024*1024 ||
iterations < 1 || iterations > 10 ||
threads < 1 || threads > 16 {
return params, nil, nil, errors.New("user: paramètres Argon2id hors limites")
}
params = argon2Params{
memory: memory,
time: iterations,
threads: uint8(threads),
}
salt, err := base64.RawStdEncoding.DecodeString(parts[4])
if err != nil || len(salt) < 8 || len(salt) > 64 {
return params, nil, nil, errors.New("user: sel Argon2id invalide")
}
key, err := base64.RawStdEncoding.DecodeString(parts[5])
if err != nil || len(key) < 16 || len(key) > 64 {
return params, nil, nil, errors.New("user: clé Argon2id invalide")
}
return params, salt, key, nil
}
+77
View File
@@ -0,0 +1,77 @@
package user
import (
"errors"
"strings"
"testing"
)
func TestHashPasswordAndVerify(t *testing.T) {
password := "correct horse battery staple"
hash, err := HashPassword(password)
if err != nil {
t.Fatalf("HashPassword : %v", err)
}
if !strings.HasPrefix(hash, "$argon2id$v=19$") {
t.Fatalf("hash inattendu : %q", hash)
}
valid, err := VerifyPassword(password, hash)
if err != nil {
t.Fatalf("VerifyPassword : %v", err)
}
if !valid {
t.Fatal("le mot de passe correct a été refusé")
}
valid, err = VerifyPassword("mauvais mot de passe", hash)
if err != nil {
t.Fatalf("VerifyPassword (mauvais) : %v", err)
}
if valid {
t.Fatal("un mauvais mot de passe a été accepté")
}
}
func TestHashPasswordUsesRandomSalt(t *testing.T) {
password := "correct horse battery staple"
first, err := HashPassword(password)
if err != nil {
t.Fatalf("HashPassword : %v", err)
}
second, err := HashPassword(password)
if err != nil {
t.Fatalf("HashPassword : %v", err)
}
if first == second {
t.Fatal("deux hashes du même mot de passe sont identiques")
}
}
func TestHashPasswordRejectsWeakPassword(t *testing.T) {
_, err := HashPassword("court")
if !errors.Is(err, ErrWeakPassword) {
t.Fatalf("erreur = %v, attendu ErrWeakPassword", err)
}
}
func TestVerifyPasswordRejectsMalformedHash(t *testing.T) {
cases := []string{
"",
"plaintext",
"$argon2id$v=19$m=19456,t=2,p=1$sel$hash",
"$argon2id$v=19$m=19456,t=2,p=1$!!!$!!!",
"$argon2id$v=18$m=19456,t=2,p=1$c2Vs$c2Vs",
}
for _, encoded := range cases {
if _, err := VerifyPassword("correct horse battery staple", encoded); err == nil {
t.Fatalf("hash %q accepté", encoded)
}
}
}
+3 -2
View File
@@ -1,6 +1,7 @@
package user
const (
ADMIN = "admin"
MEMBER = "member"
RoleAdmin = "admin"
RoleMember = "member"
RoleGuest = "guest"
)
+54
View File
@@ -0,0 +1,54 @@
package user
import (
"context"
"database/sql"
"errors"
"fmt"
"strings"
"mediarr/database"
)
type Service struct {
db database.DatabaseClient
}
func NewService(db database.DatabaseClient) *Service {
return &Service{db: db}
}
func (s *Service) withTx(ctx context.Context, fn func(*database.Queries) error) error {
tx, err := s.db.WriteDB.BeginTx(ctx, nil)
if err != nil {
return err
}
defer func() {
_ = tx.Rollback()
}()
if err := fn(s.db.WriteQueries.WithTx(tx)); err != nil {
return err
}
return tx.Commit()
}
func isUniqueViolation(err error) bool {
return err != nil && strings.Contains(strings.ToLower(err.Error()), "unique constraint failed")
}
func (s *Service) groupByName(ctx context.Context, name string) (database.Principal, error) {
group, err := s.db.Queries.GetPrincipalByNameAndKind(ctx, database.GetPrincipalByNameAndKindParams{
Kind: "group",
Name: name,
})
if err != nil {
if errors.Is(err, sql.ErrNoRows) {
return database.Principal{}, fmt.Errorf("%w: %s", ErrGroupNotFound, name)
}
return database.Principal{}, err
}
return group, nil
}
+258
View File
@@ -0,0 +1,258 @@
package user
import (
"context"
"crypto/rand"
"crypto/sha256"
"database/sql"
"encoding/base64"
"errors"
"fmt"
"time"
"mediarr/database"
"mediarr/ident"
)
const (
sessionTokenBytes = 32
defaultSessionTTL = 30 * 24 * time.Hour
defaultIdleTTL = 7 * 24 * time.Hour
)
type Session struct {
ID ident.UUID
PrincipalID ident.UUID
Kind string
Label string
CreatedAt int64
LastSeenAt int64
ExpiresAt int64
IdleExpiresAt int64
}
type CreateSessionParams struct {
PrincipalID ident.UUID
Kind string
Label string
UserAgent string
IPPrefix string
TTL time.Duration
IdleTTL time.Duration
}
func (s *Service) CreateSession(ctx context.Context, params CreateSessionParams) (*Session, string, error) {
kind := params.Kind
if kind == "" {
kind = "web"
}
if kind != "web" && kind != "api" {
return nil, "", fmt.Errorf("%w: type de session %q", ErrInvalidSession, kind)
}
principal, err := s.db.Queries.GetPrincipal(ctx, params.PrincipalID)
if err != nil {
if errors.Is(err, sql.ErrNoRows) {
return nil, "", ErrInvalidSession
}
return nil, "", err
}
if principal.Status != "active" {
return nil, "", ErrInvalidSession
}
now := time.Now().UnixMilli()
account, err := s.db.Queries.GetAccount(ctx, params.PrincipalID)
switch {
case err == nil:
switch account.State {
case "active":
case "disabled":
return nil, "", ErrAccountDisabled
case "locked":
if !account.LockedUntil.Valid || account.LockedUntil.Int64 > now {
return nil, "", ErrAccountLocked
}
}
case !errors.Is(err, sql.ErrNoRows):
return nil, "", err
}
ttl := params.TTL
if ttl <= 0 {
ttl = defaultSessionTTL
}
idleTTL := params.IdleTTL
if idleTTL <= 0 {
idleTTL = defaultIdleTTL
}
tokenBytes := make([]byte, sessionTokenBytes)
if _, err := rand.Read(tokenBytes); err != nil {
return nil, "", fmt.Errorf("user: génération du token de session : %w", err)
}
token := base64.RawURLEncoding.EncodeToString(tokenBytes)
tokenHash := sha256.Sum256([]byte(token))
expiresAt := now + ttl.Milliseconds()
idleExpiresAt := now + idleTTL.Milliseconds()
if idleExpiresAt > expiresAt {
idleExpiresAt = expiresAt
}
sessionID, err := ident.NewV7()
if err != nil {
return nil, "", err
}
session, err := s.db.WriteQueries.CreateSession(ctx, database.CreateSessionParams{
ID: sessionID,
TokenHash: tokenHash[:],
PrincipalID: params.PrincipalID,
Kind: kind,
Label: nullableString(params.Label),
UserAgent: nullableString(params.UserAgent),
IpPrefix: nullableString(params.IPPrefix),
CreatedAt: now,
LastSeenAt: now,
ExpiresAt: expiresAt,
IdleExpiresAt: idleExpiresAt,
})
if err != nil {
return nil, "", err
}
return sessionFromDB(session), token, nil
}
func (s *Service) ValidateSession(ctx context.Context, token string) (*Session, *User, error) {
if token == "" {
return nil, nil, ErrInvalidSession
}
tokenHash := sha256.Sum256([]byte(token))
session, err := s.db.Queries.GetSessionByTokenHash(ctx, tokenHash[:])
if err != nil {
if errors.Is(err, sql.ErrNoRows) {
return nil, nil, ErrInvalidSession
}
return nil, nil, err
}
now := time.Now().UnixMilli()
if session.RevokedAt.Valid || session.ExpiresAt <= now || session.IdleExpiresAt <= now {
return nil, nil, ErrInvalidSession
}
user, err := s.loadUser(ctx, session.PrincipalID)
if err != nil {
if errors.Is(err, sql.ErrNoRows) {
return nil, nil, ErrInvalidSession
}
return nil, nil, err
}
if user.Status != "active" || user.AccountState == "disabled" {
return nil, nil, ErrInvalidSession
}
idleTTL := session.IdleExpiresAt - session.LastSeenAt
if idleTTL <= 0 {
idleTTL = defaultIdleTTL.Milliseconds()
}
idleExpiresAt := now + idleTTL
if idleExpiresAt > session.ExpiresAt {
idleExpiresAt = session.ExpiresAt
}
updated, err := s.db.WriteQueries.TouchSession(ctx, database.TouchSessionParams{
LastSeenAt: now,
IdleExpiresAt: idleExpiresAt,
ID: session.ID,
})
if err != nil {
return nil, nil, err
}
return sessionFromDB(updated), user, nil
}
func (s *Service) RevokeSession(ctx context.Context, sessionID ident.UUID) error {
_, err := s.db.WriteQueries.RevokeSession(ctx, database.RevokeSessionParams{
RevokedAt: sql.NullInt64{
Int64: time.Now().UnixMilli(),
Valid: true,
},
ID: sessionID,
})
if err != nil {
if errors.Is(err, sql.ErrNoRows) {
return ErrInvalidSession
}
return err
}
return nil
}
func (s *Service) RevokeSessionByToken(ctx context.Context, token string) error {
if token == "" {
return ErrInvalidSession
}
tokenHash := sha256.Sum256([]byte(token))
_, err := s.db.WriteQueries.RevokeSessionByTokenHash(ctx, database.RevokeSessionByTokenHashParams{
RevokedAt: sql.NullInt64{
Int64: time.Now().UnixMilli(),
Valid: true,
},
TokenHash: tokenHash[:],
})
if err != nil {
if errors.Is(err, sql.ErrNoRows) {
return ErrInvalidSession
}
return err
}
return nil
}
func (s *Service) ListSessions(ctx context.Context, principalID ident.UUID) ([]Session, error) {
rows, err := s.db.Queries.ListSessionsByPrincipal(ctx, principalID)
if err != nil {
return nil, err
}
sessions := make([]Session, 0, len(rows))
for _, row := range rows {
sessions = append(sessions, *sessionFromDB(row))
}
return sessions, nil
}
func (s *Service) DeleteExpiredSessions(ctx context.Context) (int64, error) {
return s.db.WriteQueries.DeleteExpiredSessions(ctx, time.Now().UnixMilli())
}
func sessionFromDB(session database.Session) *Session {
return &Session{
ID: session.ID,
PrincipalID: session.PrincipalID,
Kind: session.Kind,
Label: session.Label.String,
CreatedAt: session.CreatedAt,
LastSeenAt: session.LastSeenAt,
ExpiresAt: session.ExpiresAt,
IdleExpiresAt: session.IdleExpiresAt,
}
}
func nullableString(value string) sql.NullString {
if value == "" {
return sql.NullString{}
}
return sql.NullString{String: value, Valid: true}
}
+307
View File
@@ -0,0 +1,307 @@
package user
import (
"context"
"crypto/sha256"
"database/sql"
"errors"
"testing"
"time"
"mediarr/database"
"mediarr/ident"
)
func TestCreateAndValidateSession(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
created := mustCreateUser(t, service, "alice", "correct horse battery staple", RoleMember)
session, token, err := service.CreateSession(ctx, CreateSessionParams{
PrincipalID: created.ID,
Kind: "web",
Label: "test",
UserAgent: "go-test",
IPPrefix: "127.0.0.",
})
if err != nil {
t.Fatalf("CreateSession : %v", err)
}
if token == "" {
t.Fatal("token vide")
}
if session.ID.IsZero() {
t.Fatal("identifiant de session vide")
}
tokenHash := sha256.Sum256([]byte(token))
stored, err := service.db.Queries.GetSessionByTokenHash(ctx, tokenHash[:])
if err != nil {
t.Fatalf("GetSessionByTokenHash : %v", err)
}
if len(stored.TokenHash) != 32 {
t.Fatalf("token_hash de %d octets, attendu 32", len(stored.TokenHash))
}
validated, authenticated, err := service.ValidateSession(ctx, token)
if err != nil {
t.Fatalf("ValidateSession : %v", err)
}
if validated.ID != session.ID {
t.Fatalf("id = %s, attendu %s", validated.ID, session.ID)
}
if authenticated.ID != created.ID {
t.Fatalf("utilisateur = %s, attendu %s", authenticated.ID, created.ID)
}
if validated.LastSeenAt < session.LastSeenAt {
t.Fatalf("last_seen_at = %d, attendu >= %d", validated.LastSeenAt, session.LastSeenAt)
}
}
func TestValidateSessionRejectsUnknownToken(t *testing.T) {
service := newTestService(t)
_, _, err := service.ValidateSession(context.Background(), "inconnu")
if !errors.Is(err, ErrInvalidSession) {
t.Fatalf("erreur = %v, attendu ErrInvalidSession", err)
}
}
func TestRevokeSession(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
created := mustCreateUser(t, service, "alice", "correct horse battery staple", RoleMember)
session, token, err := service.CreateSession(ctx, CreateSessionParams{PrincipalID: created.ID})
if err != nil {
t.Fatalf("CreateSession : %v", err)
}
if err := service.RevokeSession(ctx, session.ID); err != nil {
t.Fatalf("RevokeSession : %v", err)
}
_, _, err = service.ValidateSession(ctx, token)
if !errors.Is(err, ErrInvalidSession) {
t.Fatalf("erreur = %v, attendu ErrInvalidSession", err)
}
}
func TestRevokeSessionByToken(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
created := mustCreateUser(t, service, "alice", "correct horse battery staple", RoleMember)
_, token, err := service.CreateSession(ctx, CreateSessionParams{PrincipalID: created.ID})
if err != nil {
t.Fatalf("CreateSession : %v", err)
}
if err := service.RevokeSessionByToken(ctx, token); err != nil {
t.Fatalf("RevokeSessionByToken : %v", err)
}
_, _, err = service.ValidateSession(ctx, token)
if !errors.Is(err, ErrInvalidSession) {
t.Fatalf("erreur = %v, attendu ErrInvalidSession", err)
}
}
func TestValidateSessionRejectsExpiredSession(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
created := mustCreateUser(t, service, "alice", "correct horse battery staple", RoleMember)
token := "session-expiree"
tokenHash := sha256.Sum256([]byte(token))
now := time.Now().UnixMilli()
sessionID, err := ident.NewV7()
if err != nil {
t.Fatalf("NewV7 : %v", err)
}
_, err = service.db.WriteQueries.CreateSession(ctx, database.CreateSessionParams{
ID: sessionID,
TokenHash: tokenHash[:],
PrincipalID: created.ID,
Kind: "web",
CreatedAt: now - 2000,
LastSeenAt: now - 2000,
ExpiresAt: now - 1,
IdleExpiresAt: now + 60_000,
})
if err != nil {
t.Fatalf("CreateSession : %v", err)
}
_, _, err = service.ValidateSession(ctx, token)
if !errors.Is(err, ErrInvalidSession) {
t.Fatalf("erreur = %v, attendu ErrInvalidSession", err)
}
}
func TestValidateSessionRejectsIdleExpiredSession(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
created := mustCreateUser(t, service, "alice", "correct horse battery staple", RoleMember)
token := "session-inactive"
tokenHash := sha256.Sum256([]byte(token))
now := time.Now().UnixMilli()
sessionID, err := ident.NewV7()
if err != nil {
t.Fatalf("NewV7 : %v", err)
}
_, err = service.db.WriteQueries.CreateSession(ctx, database.CreateSessionParams{
ID: sessionID,
TokenHash: tokenHash[:],
PrincipalID: created.ID,
Kind: "web",
CreatedAt: now - 2000,
LastSeenAt: now - 2000,
ExpiresAt: now + 60_000,
IdleExpiresAt: now - 1,
})
if err != nil {
t.Fatalf("CreateSession : %v", err)
}
_, _, err = service.ValidateSession(ctx, token)
if !errors.Is(err, ErrInvalidSession) {
t.Fatalf("erreur = %v, attendu ErrInvalidSession", err)
}
}
func TestCreateSessionRejectsInactivePrincipal(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
created := mustCreateUser(t, service, "alice", "correct horse battery staple", RoleMember)
_, err := service.db.WriteQueries.UpdatePrincipalStatus(ctx, database.UpdatePrincipalStatusParams{
Status: "disabled",
DisabledAt: sql.NullInt64{
Int64: time.Now().UnixMilli(),
Valid: true,
},
ID: created.ID,
})
if err != nil {
t.Fatalf("UpdatePrincipalStatus : %v", err)
}
_, _, err = service.CreateSession(ctx, CreateSessionParams{PrincipalID: created.ID})
if !errors.Is(err, ErrInvalidSession) {
t.Fatalf("erreur = %v, attendu ErrInvalidSession", err)
}
}
func TestListAndDeleteExpiredSessions(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
created := mustCreateUser(t, service, "alice", "correct horse battery staple", RoleMember)
_, _, err := service.CreateSession(ctx, CreateSessionParams{PrincipalID: created.ID})
if err != nil {
t.Fatalf("CreateSession : %v", err)
}
token := "session-expiree-liste"
tokenHash := sha256.Sum256([]byte(token))
now := time.Now().UnixMilli()
sessionID, err := ident.NewV7()
if err != nil {
t.Fatalf("NewV7 : %v", err)
}
_, err = service.db.WriteQueries.CreateSession(ctx, database.CreateSessionParams{
ID: sessionID,
TokenHash: tokenHash[:],
PrincipalID: created.ID,
Kind: "web",
CreatedAt: now - 2000,
LastSeenAt: now - 2000,
ExpiresAt: now - 1,
IdleExpiresAt: now - 1,
})
if err != nil {
t.Fatalf("CreateSession : %v", err)
}
sessions, err := service.ListSessions(ctx, created.ID)
if err != nil {
t.Fatalf("ListSessions : %v", err)
}
if len(sessions) != 2 {
t.Fatalf("sessions = %d, attendu 2", len(sessions))
}
deleted, err := service.DeleteExpiredSessions(ctx)
if err != nil {
t.Fatalf("DeleteExpiredSessions : %v", err)
}
if deleted != 1 {
t.Fatalf("sessions supprimées = %d, attendu 1", deleted)
}
sessions, err = service.ListSessions(ctx, created.ID)
if err != nil {
t.Fatalf("ListSessions : %v", err)
}
if len(sessions) != 1 {
t.Fatalf("sessions = %d, attendu 1", len(sessions))
}
}
func TestGuestSession(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
guestID, err := ident.NewV7()
if err != nil {
t.Fatalf("NewV7 : %v", err)
}
_, err = service.db.WriteQueries.CreatePrincipal(ctx, database.CreatePrincipalParams{
ID: guestID,
Kind: "guest",
Name: "jean",
Status: "active",
CreatedAt: time.Now().UnixMilli(),
})
if err != nil {
t.Fatalf("CreatePrincipal : %v", err)
}
session, token, err := service.CreateSession(ctx, CreateSessionParams{PrincipalID: guestID})
if err != nil {
t.Fatalf("CreateSession : %v", err)
}
validated, guest, err := service.ValidateSession(ctx, token)
if err != nil {
t.Fatalf("ValidateSession : %v", err)
}
if validated.ID != session.ID {
t.Fatalf("id = %s, attendu %s", validated.ID, session.ID)
}
if guest.ID != guestID {
t.Fatalf("id invité = %s, attendu %s", guest.ID, guestID)
}
if guest.Login != "jean" {
t.Fatalf("login = %q, attendu jean", guest.Login)
}
if guest.AccountState != "active" {
t.Fatalf("état = %q, attendu active", guest.AccountState)
}
}
+258 -14
View File
@@ -1,26 +1,270 @@
package user
import (
"context"
"database/sql"
"errors"
"fmt"
"time"
"mediarr/database"
"mediarr/ident"
)
const (
maxFailedAttempts = 5
lockDuration = 15 * time.Minute
)
type User struct {
Username string
ID ident.UUID
Login string
Name string
Status string
AccountState string
MustChangePassword bool
CreatedAt int64
Groups []Group
}
type Group struct {
ID ident.UUID
Name string
Role string
}
type CreateUserParams struct {
Login string
Password string
Email *string
Role string
}
type NewUserParams struct {
Username string
Password string
}
func NewUser(params NewUserParams) User {
return User{
Username: params.Username,
Password: params.Password,
func (s *Service) CreateUser(ctx context.Context, params CreateUserParams) (*User, 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 = RoleMember
}
groupName, err := groupNameForRole(role)
if err != nil {
return nil, err
}
group, err := s.groupByName(ctx, groupName)
if err != nil {
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: "user",
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: "member",
CreatedAt: now,
})
return err
})
if err != nil {
if isUniqueViolation(err) {
return nil, fmt.Errorf("%w: %s", ErrLoginTaken, display)
}
return nil, err
}
return s.loadUser(ctx, userID)
}
func (u *User) Is(role string) bool {
return role == u.Role
func (s *Service) Authenticate(ctx context.Context, login, password string) (*User, 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.loadUser(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) loadUser(ctx context.Context, id ident.UUID) (*User, error) {
principal, err := s.db.Queries.GetPrincipal(ctx, id)
if err != nil {
return nil, err
}
login := principal.Name
accountState := "active"
mustChangePassword := false
account, err := s.db.Queries.GetAccount(ctx, id)
switch {
case err == nil:
login = account.Login
accountState = account.State
mustChangePassword = account.MustChangePassword != 0
case !errors.Is(err, sql.ErrNoRows):
return nil, err
}
groups, err := s.ListGroups(ctx, id)
if err != nil {
return nil, err
}
return &User{
ID: principal.ID,
Login: login,
Name: principal.Name,
Status: principal.Status,
AccountState: accountState,
MustChangePassword: mustChangePassword,
CreatedAt: principal.CreatedAt,
Groups: groups,
}, nil
}
+281
View File
@@ -0,0 +1,281 @@
package user
import (
"context"
"database/sql"
"errors"
"testing"
"time"
"mediarr/database"
)
func TestCreateUser(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
created, err := service.CreateUser(ctx, CreateUserParams{
Login: "Alice",
Password: "correct horse battery staple",
})
if err != nil {
t.Fatalf("CreateUser : %v", err)
}
if created.ID.IsZero() {
t.Fatal("identifiant utilisateur vide")
}
if created.Login != "Alice" {
t.Fatalf("login = %q, attendu Alice", created.Login)
}
if created.Name != "Alice" {
t.Fatalf("name = %q, attendu Alice", created.Name)
}
if created.Status != "active" {
t.Fatalf("status = %q, attendu active", created.Status)
}
if created.AccountState != "active" {
t.Fatalf("état du compte = %q, attendu active", created.AccountState)
}
if len(created.Groups) != 1 || created.Groups[0].Name != "members" {
t.Fatalf("groupes = %+v, attendu members", created.Groups)
}
principal, err := service.db.Queries.GetPrincipal(ctx, created.ID)
if err != nil {
t.Fatalf("GetPrincipal : %v", err)
}
if principal.Kind != "user" {
t.Fatalf("kind = %q, attendu user", principal.Kind)
}
account, err := service.db.Queries.GetAccountByLoginKey(ctx, "alice")
if err != nil {
t.Fatalf("GetAccountByLoginKey : %v", err)
}
if !account.PasswordHash.Valid {
t.Fatal("hash du mot de passe absent")
}
if account.PasswordHash.String == "correct horse battery staple" {
t.Fatal("le mot de passe est stocké en clair")
}
}
func TestCreateUserRejectsDuplicateLogin(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
mustCreateUser(t, service, "alice", "correct horse battery staple", RoleMember)
_, err := service.CreateUser(ctx, CreateUserParams{
Login: "ALICE",
Password: "another correct horse battery staple",
})
if !errors.Is(err, ErrLoginTaken) {
t.Fatalf("erreur = %v, attendu ErrLoginTaken", err)
}
}
func TestCreateUserRejectsInvalidInput(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
_, err := service.CreateUser(ctx, CreateUserParams{
Login: " ",
Password: "correct horse battery staple",
})
if !errors.Is(err, ErrInvalidLogin) {
t.Fatalf("login vide : erreur = %v, attendu ErrInvalidLogin", err)
}
_, err = service.CreateUser(ctx, CreateUserParams{
Login: "alice",
Password: "court",
})
if !errors.Is(err, ErrWeakPassword) {
t.Fatalf("mot de passe faible : erreur = %v, attendu ErrWeakPassword", err)
}
_, err = service.CreateUser(ctx, CreateUserParams{
Login: "alice",
Password: "correct horse battery staple",
Role: "super-admin",
})
if !errors.Is(err, ErrInvalidRole) {
t.Fatalf("rôle invalide : erreur = %v, attendu ErrInvalidRole", err)
}
}
func TestCreateUserAdmin(t *testing.T) {
service := newTestService(t)
created := mustCreateUser(t, service, "root", "correct horse battery staple", RoleAdmin)
if len(created.Groups) != 1 || created.Groups[0].Name != "admins" {
t.Fatalf("groupes = %+v, attendu admins", created.Groups)
}
}
func TestAuthenticate(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
created := mustCreateUser(t, service, "alice", "correct horse battery staple", RoleMember)
authenticated, err := service.Authenticate(ctx, "ALICE", "correct horse battery staple")
if err != nil {
t.Fatalf("Authenticate : %v", err)
}
if authenticated.ID != created.ID {
t.Fatalf("id = %s, attendu %s", authenticated.ID, created.ID)
}
account, err := service.db.Queries.GetAccount(ctx, created.ID)
if err != nil {
t.Fatalf("GetAccount : %v", err)
}
if !account.LastLoginAt.Valid {
t.Fatal("last_login_at non renseigné")
}
}
func TestAuthenticateRejectsUnknownLogin(t *testing.T) {
service := newTestService(t)
_, err := service.Authenticate(context.Background(), "inconnu", "correct horse battery staple")
if !errors.Is(err, ErrInvalidCredentials) {
t.Fatalf("erreur = %v, attendu ErrInvalidCredentials", err)
}
}
func TestAuthenticateRejectsWrongPassword(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
created := mustCreateUser(t, service, "alice", "correct horse battery staple", RoleMember)
_, err := service.Authenticate(ctx, "alice", "mauvais mot de passe")
if !errors.Is(err, ErrInvalidCredentials) {
t.Fatalf("erreur = %v, attendu ErrInvalidCredentials", err)
}
account, err := service.db.Queries.GetAccount(ctx, created.ID)
if err != nil {
t.Fatalf("GetAccount : %v", err)
}
if account.FailedAttempts != 1 {
t.Fatalf("failed_attempts = %d, attendu 1", account.FailedAttempts)
}
}
func TestAuthenticateLocksAccountAfterTooManyFailures(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
created := mustCreateUser(t, service, "alice", "correct horse battery staple", RoleMember)
for attempt := 1; attempt <= maxFailedAttempts; attempt++ {
_, err := service.Authenticate(ctx, "alice", "mauvais mot de passe")
if attempt < maxFailedAttempts {
if !errors.Is(err, ErrInvalidCredentials) {
t.Fatalf("tentative %d : erreur = %v, attendu ErrInvalidCredentials", attempt, err)
}
continue
}
if !errors.Is(err, ErrAccountLocked) {
t.Fatalf("tentative %d : erreur = %v, attendu ErrAccountLocked", attempt, err)
}
}
_, err := service.Authenticate(ctx, "alice", "correct horse battery staple")
if !errors.Is(err, ErrAccountLocked) {
t.Fatalf("erreur = %v, attendu ErrAccountLocked", err)
}
account, err := service.db.Queries.GetAccount(ctx, created.ID)
if err != nil {
t.Fatalf("GetAccount : %v", err)
}
if account.State != "locked" {
t.Fatalf("state = %q, attendu locked", account.State)
}
if !account.LockedUntil.Valid || account.LockedUntil.Int64 <= time.Now().UnixMilli() {
t.Fatalf("locked_until = %+v, attendu dans le futur", account.LockedUntil)
}
}
func TestAuthenticateUnlocksExpiredAccount(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
created := mustCreateUser(t, service, "alice", "correct horse battery staple", RoleMember)
_, err := service.db.WriteQueries.LockAccount(ctx, database.LockAccountParams{
LockedUntil: sql.NullInt64{
Int64: time.Now().Add(-time.Minute).UnixMilli(),
Valid: true,
},
PrincipalID: created.ID,
})
if err != nil {
t.Fatalf("LockAccount : %v", err)
}
_, err = service.Authenticate(ctx, "alice", "correct horse battery staple")
if err != nil {
t.Fatalf("Authenticate : %v", err)
}
account, err := service.db.Queries.GetAccount(ctx, created.ID)
if err != nil {
t.Fatalf("GetAccount : %v", err)
}
if account.State != "active" {
t.Fatalf("state = %q, attendu active", account.State)
}
if account.FailedAttempts != 0 {
t.Fatalf("failed_attempts = %d, attendu 0", account.FailedAttempts)
}
}
func TestAuthenticateRejectsDisabledAccount(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
created := mustCreateUser(t, service, "alice", "correct horse battery staple", RoleMember)
_, err := service.db.WriteQueries.UpdateAccountState(ctx, database.UpdateAccountStateParams{
State: "disabled",
PrincipalID: created.ID,
})
if err != nil {
t.Fatalf("UpdateAccountState : %v", err)
}
_, err = service.Authenticate(ctx, "alice", "correct horse battery staple")
if !errors.Is(err, ErrAccountDisabled) {
t.Fatalf("erreur = %v, attendu ErrAccountDisabled", err)
}
}
func TestSetPassword(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
created := mustCreateUser(t, service, "alice", "correct horse battery staple", RoleMember)
if err := service.SetPassword(ctx, created.ID, "nouveau correct horse battery staple"); err != nil {
t.Fatalf("SetPassword : %v", err)
}
_, err := service.Authenticate(ctx, "alice", "correct horse battery staple")
if !errors.Is(err, ErrInvalidCredentials) {
t.Fatalf("ancien mot de passe : erreur = %v, attendu ErrInvalidCredentials", err)
}
_, err = service.Authenticate(ctx, "alice", "nouveau correct horse battery staple")
if err != nil {
t.Fatalf("nouveau mot de passe : %v", err)
}
}