Compare commits

..
2 Commits
Author SHA1 Message Date
venture 9d4f827d38 add acl 2026-11-14 10:53:22 +01:00
venture f16363cb60 replace static status definition by const 2026-11-14 09:57:52 +01:00
22 changed files with 1565 additions and 60 deletions
+70
View File
@@ -0,0 +1,70 @@
package acl
import (
"errors"
"time"
"mediarr/ident"
)
type Permission int64
const (
PermissionRead Permission = 1 << iota
PermissionWrite
PermissionCreate
PermissionDelete
PermissionShare
PermissionManage
PermissionAdmin
)
const PermissionAll = PermissionRead |
PermissionWrite |
PermissionCreate |
PermissionDelete |
PermissionShare |
PermissionManage |
PermissionAdmin
func (p Permission) Valid() bool {
return p > 0 && p <= PermissionAll
}
func (p Permission) Has(required Permission) bool {
if required == 0 {
return true
}
if !required.Valid() {
return false
}
return p&PermissionAdmin != 0 || p&required == required
}
type Entry struct {
ID ident.UUID
DocumentID ident.UUID
SubjectID ident.UUID
Permissions Permission
Propagate bool
ExpiresAt *time.Time
GrantedBy ident.UUID
CreatedAt time.Time
}
type GrantParams struct {
DocumentID ident.UUID
SubjectID ident.UUID
Permissions Permission
Propagate bool
ExpiresAt *time.Time
GrantedBy ident.UUID
}
var (
ErrInvalidPermissions = errors.New("permissions invalides")
ErrDocumentNotFound = errors.New("document introuvable")
ErrSubjectNotFound = errors.New("sujet ACL introuvable")
ErrEntryNotFound = errors.New("entrée ACL introuvable")
ErrDocumentCycle = errors.New("cycle dans l'arborescence des documents")
)
+123
View File
@@ -0,0 +1,123 @@
package acl
import (
"context"
"database/sql"
"errors"
"fmt"
"time"
"mediarr/database"
"mediarr/ident"
)
func (s *Service) Grant(ctx context.Context, params GrantParams) (*Entry, error) {
if !params.Permissions.Valid() {
return nil, fmt.Errorf("%w: %d", ErrInvalidPermissions, params.Permissions)
}
if _, err := s.db.Queries.GetDocument(ctx, params.DocumentID); err != nil {
if errors.Is(err, sql.ErrNoRows) {
return nil, fmt.Errorf("%w: %s", ErrDocumentNotFound, params.DocumentID)
}
return nil, err
}
if _, err := s.loadSubject(ctx, params.SubjectID); err != nil {
return nil, err
}
id, err := ident.NewV7()
if err != nil {
return nil, err
}
now := time.Now()
entry, err := s.db.WriteQueries.UpsertACLEntry(ctx, database.UpsertACLEntryParams{
ID: id,
DocumentID: params.DocumentID,
SubjectID: params.SubjectID,
Permissions: int64(params.Permissions),
Propagate: boolToInt(params.Propagate),
ExpiresAt: timeToNull(params.ExpiresAt),
GrantedBy: params.GrantedBy,
CreatedAt: now.UnixMilli(),
})
if err != nil {
return nil, err
}
return entryFromDB(entry), nil
}
func (s *Service) Revoke(ctx context.Context, documentID, subjectID ident.UUID) error {
_, err := s.db.WriteQueries.RevokeACLEntry(ctx, database.RevokeACLEntryParams{
RevokedAt: sql.NullInt64{
Int64: time.Now().UnixMilli(),
Valid: true,
},
DocumentID: documentID,
SubjectID: subjectID,
})
if err != nil {
if errors.Is(err, sql.ErrNoRows) {
return ErrEntryNotFound
}
return err
}
return nil
}
func (s *Service) List(ctx context.Context, documentID ident.UUID) ([]Entry, error) {
rows, err := s.db.Queries.ListActiveACLEntriesForDocument(ctx, database.ListActiveACLEntriesForDocumentParams{
DocumentID: documentID,
Now: time.Now().UnixMilli(),
})
if err != nil {
return nil, err
}
entries := make([]Entry, 0, len(rows))
for _, row := range rows {
entries = append(entries, *entryFromDB(row))
}
return entries, nil
}
func entryFromDB(entry database.AclEntry) *Entry {
return &Entry{
ID: entry.ID,
DocumentID: entry.DocumentID,
SubjectID: entry.SubjectID,
Permissions: Permission(entry.Permissions),
Propagate: entry.Propagate != 0,
ExpiresAt: nullToTime(entry.ExpiresAt),
GrantedBy: entry.GrantedBy,
CreatedAt: time.UnixMilli(entry.CreatedAt),
}
}
func boolToInt(value bool) int64 {
if value {
return 1
}
return 0
}
func timeToNull(value *time.Time) sql.NullInt64 {
if value == nil {
return sql.NullInt64{}
}
return sql.NullInt64{Int64: value.UnixMilli(), Valid: true}
}
func nullToTime(value sql.NullInt64) *time.Time {
if !value.Valid {
return nil
}
result := time.UnixMilli(value.Int64)
return &result
}
+279
View File
@@ -0,0 +1,279 @@
package acl
import (
"context"
"errors"
"testing"
"time"
"mediarr/ident"
)
func TestGrantAndList(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
owner := mustUser(t, service, "owner")
alice := mustUser(t, service, "alice")
documentID := mustDocument(t, service, owner.ID, nil, "Photos", "", true)
expiresAt := time.Now().Add(time.Hour).Truncate(time.Millisecond)
entry, err := service.Grant(ctx, GrantParams{
DocumentID: documentID,
SubjectID: alice.ID,
Permissions: PermissionRead | PermissionWrite,
Propagate: true,
ExpiresAt: &expiresAt,
GrantedBy: owner.ID,
})
if err != nil {
t.Fatalf("Grant : %v", err)
}
if entry.SubjectID != alice.ID {
t.Fatalf("subject = %s, attendu %s", entry.SubjectID, alice.ID)
}
if entry.Permissions != PermissionRead|PermissionWrite {
t.Fatalf("permissions = %d, attendu %d", entry.Permissions, PermissionRead|PermissionWrite)
}
if !entry.Propagate {
t.Fatal("propagate = false, attendu true")
}
if entry.ExpiresAt == nil || !entry.ExpiresAt.Equal(expiresAt) {
t.Fatalf("expires_at = %v, attendu %v", entry.ExpiresAt, expiresAt)
}
entries, err := service.List(ctx, documentID)
if err != nil {
t.Fatalf("List : %v", err)
}
if len(entries) != 1 {
t.Fatalf("entrées = %d, attendu 1", len(entries))
}
if entries[0].ID != entry.ID {
t.Fatalf("id = %s, attendu %s", entries[0].ID, entry.ID)
}
}
func TestGrantUpsertsExistingEntry(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
owner := mustUser(t, service, "owner")
alice := mustUser(t, service, "alice")
documentID := mustDocument(t, service, owner.ID, nil, "Photos", "", true)
if _, err := service.Grant(ctx, GrantParams{
DocumentID: documentID,
SubjectID: alice.ID,
Permissions: PermissionRead,
GrantedBy: owner.ID,
}); err != nil {
t.Fatalf("premier Grant : %v", err)
}
if _, err := service.Grant(ctx, GrantParams{
DocumentID: documentID,
SubjectID: alice.ID,
Permissions: PermissionWrite,
GrantedBy: owner.ID,
}); err != nil {
t.Fatalf("second Grant : %v", err)
}
entries, err := service.List(ctx, documentID)
if err != nil {
t.Fatalf("List : %v", err)
}
if len(entries) != 1 {
t.Fatalf("entrées = %d, attendu 1", len(entries))
}
if entries[0].Permissions != PermissionWrite {
t.Fatalf("permissions = %d, attendu %d", entries[0].Permissions, PermissionWrite)
}
}
func TestGrantRejectsInvalidPermissions(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
owner := mustUser(t, service, "owner")
alice := mustUser(t, service, "alice")
documentID := mustDocument(t, service, owner.ID, nil, "Photos", "", true)
for _, permissions := range []Permission{0, PermissionAll + 1} {
_, err := service.Grant(ctx, GrantParams{
DocumentID: documentID,
SubjectID: alice.ID,
Permissions: permissions,
GrantedBy: owner.ID,
})
if !errors.Is(err, ErrInvalidPermissions) {
t.Fatalf("permissions %d : erreur = %v, attendu ErrInvalidPermissions", permissions, err)
}
}
}
func TestGrantRejectsMissingDocument(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
owner := mustUser(t, service, "owner")
alice := mustUser(t, service, "alice")
missing, err := ident.NewV7()
if err != nil {
t.Fatalf("NewV7 : %v", err)
}
_, err = service.Grant(ctx, GrantParams{
DocumentID: missing,
SubjectID: alice.ID,
Permissions: PermissionRead,
GrantedBy: owner.ID,
})
if !errors.Is(err, ErrDocumentNotFound) {
t.Fatalf("erreur = %v, attendu ErrDocumentNotFound", err)
}
}
func TestGrantRejectsMissingSubject(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
owner := mustUser(t, service, "owner")
documentID := mustDocument(t, service, owner.ID, nil, "Photos", "", true)
missing, err := ident.NewV7()
if err != nil {
t.Fatalf("NewV7 : %v", err)
}
_, err = service.Grant(ctx, GrantParams{
DocumentID: documentID,
SubjectID: missing,
Permissions: PermissionRead,
GrantedBy: owner.ID,
})
if !errors.Is(err, ErrSubjectNotFound) {
t.Fatalf("erreur = %v, attendu ErrSubjectNotFound", err)
}
}
func TestGrantRejectsInactiveSubject(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
owner := mustUser(t, service, "owner")
alice := mustUser(t, service, "alice")
documentID := mustDocument(t, service, owner.ID, nil, "Photos", "", true)
disablePrincipal(t, service, alice.ID)
_, err := service.Grant(ctx, GrantParams{
DocumentID: documentID,
SubjectID: alice.ID,
Permissions: PermissionRead,
GrantedBy: owner.ID,
})
if !errors.Is(err, ErrSubjectNotFound) {
t.Fatalf("erreur = %v, attendu ErrSubjectNotFound", err)
}
}
func TestRevoke(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
owner := mustUser(t, service, "owner")
alice := mustUser(t, service, "alice")
documentID := mustDocument(t, service, owner.ID, nil, "Photos", "", true)
if _, err := service.Grant(ctx, GrantParams{
DocumentID: documentID,
SubjectID: alice.ID,
Permissions: PermissionRead,
GrantedBy: owner.ID,
}); err != nil {
t.Fatalf("Grant : %v", err)
}
if err := service.Revoke(ctx, documentID, alice.ID); err != nil {
t.Fatalf("Revoke : %v", err)
}
entries, err := service.List(ctx, documentID)
if err != nil {
t.Fatalf("List : %v", err)
}
if len(entries) != 0 {
t.Fatalf("entrées = %d, attendu 0", len(entries))
}
if err := service.Revoke(ctx, documentID, alice.ID); !errors.Is(err, ErrEntryNotFound) {
t.Fatalf("erreur = %v, attendu ErrEntryNotFound", err)
}
}
func TestRevokeThenGrantAgain(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
owner := mustUser(t, service, "owner")
alice := mustUser(t, service, "alice")
documentID := mustDocument(t, service, owner.ID, nil, "Photos", "", true)
if _, err := service.Grant(ctx, GrantParams{
DocumentID: documentID,
SubjectID: alice.ID,
Permissions: PermissionRead,
GrantedBy: owner.ID,
}); err != nil {
t.Fatalf("Grant : %v", err)
}
if err := service.Revoke(ctx, documentID, alice.ID); err != nil {
t.Fatalf("Revoke : %v", err)
}
if _, err := service.Grant(ctx, GrantParams{
DocumentID: documentID,
SubjectID: alice.ID,
Permissions: PermissionWrite,
GrantedBy: owner.ID,
}); err != nil {
t.Fatalf("Grant après révocation : %v", err)
}
permissions, err := service.Effective(ctx, alice.ID, documentID)
if err != nil {
t.Fatalf("Effective : %v", err)
}
if permissions != PermissionWrite {
t.Fatalf("permissions = %d, attendu %d", permissions, PermissionWrite)
}
}
func TestListIgnoresExpiredEntries(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
owner := mustUser(t, service, "owner")
alice := mustUser(t, service, "alice")
documentID := mustDocument(t, service, owner.ID, nil, "Photos", "", true)
expiredAt := time.Now().Add(-time.Hour)
if _, err := service.Grant(ctx, GrantParams{
DocumentID: documentID,
SubjectID: alice.ID,
Permissions: PermissionRead,
ExpiresAt: &expiredAt,
GrantedBy: owner.ID,
}); err != nil {
t.Fatalf("Grant : %v", err)
}
entries, err := service.List(ctx, documentID)
if err != nil {
t.Fatalf("List : %v", err)
}
if len(entries) != 0 {
t.Fatalf("entrées = %d, attendu 0", len(entries))
}
}
+142
View File
@@ -0,0 +1,142 @@
package acl
import (
"context"
"encoding/hex"
"strings"
"testing"
"time"
"mediarr/database"
"mediarr/document"
"mediarr/ident"
"mediarr/identity"
)
var testPolicyID = ident.MustParse("00000000-0000-7000-8000-000000000101")
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 mustPrincipal(t *testing.T, service *Service, kind, name string) *identity.Principal {
t.Helper()
principal, err := service.identity.CreatePrincipal(context.Background(), identity.CreatePrincipalParams{
Kind: kind,
Name: name,
})
if err != nil {
t.Fatalf("CreatePrincipal(%q) : %v", name, err)
}
return principal
}
func mustUser(t *testing.T, service *Service, name string) *identity.Principal {
return mustPrincipal(t, service, identity.KindUser, name)
}
func mustGroup(t *testing.T, service *Service, name string) *identity.Principal {
return mustPrincipal(t, service, identity.KindGroup, name)
}
func addMember(t *testing.T, service *Service, groupID, memberID ident.UUID) {
t.Helper()
if err := service.identity.AddMember(context.Background(), groupID, memberID, identity.RoleMember); err != nil {
t.Fatalf("AddMember : %v", err)
}
}
func disablePrincipal(t *testing.T, service *Service, principalID ident.UUID) {
t.Helper()
_, err := service.db.WriteQueries.UpdatePrincipalStatus(context.Background(), database.UpdatePrincipalStatusParams{
Status: identity.StatusDisabled,
ID: principalID,
})
if err != nil {
t.Fatalf("UpdatePrincipalStatus : %v", err)
}
}
func mustDocument(t *testing.T, service *Service, ownerID ident.UUID, parentID *ident.UUID, name, visibility string, aclInherit bool) ident.UUID {
t.Helper()
ctx := context.Background()
id, err := ident.NewV7()
if err != nil {
t.Fatalf("NewV7 : %v", err)
}
if visibility == "" {
visibility = document.VisibilityPrivate
}
kind := "library"
path := hex.EncodeToString(id[:]) + "/"
depth := int64(0)
var parentValue any
var policy any = testPolicyID
var visibilityValue any = visibility
if parentID != nil {
parent, err := service.db.Queries.GetDocument(ctx, *parentID)
if err != nil {
t.Fatalf("GetDocument(parent) : %v", err)
}
kind = "folder"
path = parent.Path + hex.EncodeToString(id[:]) + "/"
depth = parent.Depth + 1
parentValue = *parentID
policy = nil
visibilityValue = nil
}
now := time.Now().UnixMilli()
_, err = service.db.WriteDB.ExecContext(ctx, `
INSERT INTO document (
id, kind, owner_id, created_by, parent_id, name, name_key, path, depth,
policy_id, visibility, acl_inherit, created_at, updated_at
) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
id,
kind,
ownerID,
ownerID,
parentValue,
name,
strings.ToLower(name),
path,
depth,
policy,
visibilityValue,
boolToInt(aclInherit),
now,
now,
)
if err != nil {
t.Fatalf("insertion du document %q : %v", name, err)
}
return id
}
+113
View File
@@ -0,0 +1,113 @@
package acl
import (
"context"
"database/sql"
"errors"
"time"
"mediarr/database"
"mediarr/document"
"mediarr/ident"
"mediarr/identity"
)
func (s *Service) Effective(ctx context.Context, principalID, documentID ident.UUID) (Permission, error) {
principal, err := s.identity.GetPrincipal(ctx, principalID)
if err != nil {
if errors.Is(err, sql.ErrNoRows) {
return 0, ErrSubjectNotFound
}
return 0, err
}
if principal.Status != identity.StatusActive {
return 0, nil
}
chain, err := s.documentChain(ctx, documentID)
if err != nil {
return 0, err
}
target := chain[0]
if target.OwnerID == principalID {
return PermissionAll, nil
}
subjects := map[ident.UUID]struct{}{principalID: {}}
groups, err := s.identity.ListGroups(ctx, principalID)
if err != nil {
return 0, err
}
for _, group := range groups {
if group.Status == identity.StatusActive {
subjects[group.ID] = struct{}{}
}
}
var effective Permission
now := time.Now().UnixMilli()
inherit := target.AclInherit != 0
for depth, current := range chain {
if depth > 0 && !inherit {
break
}
entries, err := s.db.Queries.ListActiveACLEntriesForDocument(ctx, database.ListActiveACLEntriesForDocumentParams{
DocumentID: current.ID,
Now: now,
})
if err != nil {
return 0, err
}
for _, entry := range entries {
if depth > 0 && entry.Propagate == 0 {
continue
}
if _, matches := subjects[entry.SubjectID]; matches {
effective |= Permission(entry.Permissions)
}
}
if depth == 0 {
inherit = current.AclInherit != 0
} else {
inherit = inherit && current.AclInherit != 0
}
}
switch effectiveVisibility(chain) {
case document.VisibilityCluster:
if principal.Kind == identity.KindUser || principal.Kind == identity.KindGuest {
effective |= PermissionRead
}
case document.VisibilityPublic:
effective |= PermissionRead
}
return effective, nil
}
func (s *Service) Can(ctx context.Context, principalID, documentID ident.UUID, required Permission) (bool, error) {
if required == 0 {
return true, nil
}
permissions, err := s.Effective(ctx, principalID, documentID)
if err != nil {
return false, err
}
return permissions.Has(required), nil
}
func effectiveVisibility(chain []database.Document) string {
for _, document := range chain {
if document.Visibility.Valid {
return document.Visibility.String
}
}
return ""
}
+424
View File
@@ -0,0 +1,424 @@
package acl
import (
"context"
"errors"
"testing"
"time"
"mediarr/document"
"mediarr/ident"
"mediarr/identity"
)
func TestPermissionValidAndHas(t *testing.T) {
if !PermissionAll.Valid() {
t.Fatal("PermissionAll devrait être valide")
}
if Permission(0).Valid() {
t.Fatal("Permission(0) devrait être invalide")
}
if (PermissionAll + 1).Valid() {
t.Fatal("PermissionAll+1 devrait être invalide")
}
if !PermissionAdmin.Has(PermissionRead) {
t.Fatal("PermissionAdmin devrait impliquer PermissionRead")
}
if !PermissionAll.Has(PermissionManage) {
t.Fatal("PermissionAll devrait contenir PermissionManage")
}
if PermissionRead.Has(PermissionWrite) {
t.Fatal("PermissionRead ne devrait pas impliquer PermissionWrite")
}
if PermissionAdmin.Has(PermissionAll + 1) {
t.Fatal("une permission requise invalide ne devrait pas être satisfaite")
}
if !Permission(0).Has(0) {
t.Fatal("aucune permission requise devrait toujours être satisfaite")
}
}
func TestOwnerHasAllPermissions(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
owner := mustUser(t, service, "owner")
documentID := mustDocument(t, service, owner.ID, nil, "Photos", "", true)
permissions, err := service.Effective(ctx, owner.ID, documentID)
if err != nil {
t.Fatalf("Effective : %v", err)
}
if permissions != PermissionAll {
t.Fatalf("permissions = %d, attendu %d", permissions, PermissionAll)
}
allowed, err := service.Can(ctx, owner.ID, documentID, PermissionAdmin)
if err != nil {
t.Fatalf("Can : %v", err)
}
if !allowed {
t.Fatal("le propriétaire devrait avoir PermissionAdmin")
}
}
func TestEffectiveDirectAndGroup(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
owner := mustUser(t, service, "owner")
alice := mustUser(t, service, "alice")
group := mustGroup(t, service, "family")
documentID := mustDocument(t, service, owner.ID, nil, "Photos", "", true)
addMember(t, service, group.ID, alice.ID)
if _, err := service.Grant(ctx, GrantParams{
DocumentID: documentID,
SubjectID: group.ID,
Permissions: PermissionRead,
GrantedBy: owner.ID,
}); err != nil {
t.Fatalf("Grant(groupe) : %v", err)
}
if _, err := service.Grant(ctx, GrantParams{
DocumentID: documentID,
SubjectID: alice.ID,
Permissions: PermissionWrite,
GrantedBy: owner.ID,
}); err != nil {
t.Fatalf("Grant(alice) : %v", err)
}
permissions, err := service.Effective(ctx, alice.ID, documentID)
if err != nil {
t.Fatalf("Effective : %v", err)
}
if permissions != PermissionRead|PermissionWrite {
t.Fatalf("permissions = %d, attendu %d", permissions, PermissionRead|PermissionWrite)
}
}
func TestEffectiveDisabledGroup(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
owner := mustUser(t, service, "owner")
alice := mustUser(t, service, "alice")
group := mustGroup(t, service, "family")
documentID := mustDocument(t, service, owner.ID, nil, "Photos", "", true)
addMember(t, service, group.ID, alice.ID)
if _, err := service.Grant(ctx, GrantParams{
DocumentID: documentID,
SubjectID: group.ID,
Permissions: PermissionRead,
GrantedBy: owner.ID,
}); err != nil {
t.Fatalf("Grant : %v", err)
}
disablePrincipal(t, service, group.ID)
permissions, err := service.Effective(ctx, alice.ID, documentID)
if err != nil {
t.Fatalf("Effective : %v", err)
}
if permissions != 0 {
t.Fatalf("permissions = %d, attendu 0", permissions)
}
}
func TestEffectiveAdminImpliesAll(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
owner := mustUser(t, service, "owner")
alice := mustUser(t, service, "alice")
documentID := mustDocument(t, service, owner.ID, nil, "Photos", "", true)
if _, err := service.Grant(ctx, GrantParams{
DocumentID: documentID,
SubjectID: alice.ID,
Permissions: PermissionAdmin,
GrantedBy: owner.ID,
}); err != nil {
t.Fatalf("Grant : %v", err)
}
allowed, err := service.Can(ctx, alice.ID, documentID, PermissionRead|PermissionDelete)
if err != nil {
t.Fatalf("Can : %v", err)
}
if !allowed {
t.Fatal("PermissionAdmin devrait impliquer toutes les permissions")
}
}
func TestEffectiveInheritance(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
owner := mustUser(t, service, "owner")
alice := mustUser(t, service, "alice")
root := mustDocument(t, service, owner.ID, nil, "Root", "", true)
folder := mustDocument(t, service, owner.ID, &root, "Folder", "", true)
child := mustDocument(t, service, owner.ID, &folder, "Child", "", true)
if _, err := service.Grant(ctx, GrantParams{
DocumentID: root,
SubjectID: alice.ID,
Permissions: PermissionRead,
Propagate: true,
GrantedBy: owner.ID,
}); err != nil {
t.Fatalf("Grant(root) : %v", err)
}
if _, err := service.Grant(ctx, GrantParams{
DocumentID: folder,
SubjectID: alice.ID,
Permissions: PermissionWrite,
Propagate: true,
GrantedBy: owner.ID,
}); err != nil {
t.Fatalf("Grant(folder) : %v", err)
}
if _, err := service.Grant(ctx, GrantParams{
DocumentID: child,
SubjectID: alice.ID,
Permissions: PermissionDelete,
GrantedBy: owner.ID,
}); err != nil {
t.Fatalf("Grant(child) : %v", err)
}
permissions, err := service.Effective(ctx, alice.ID, child)
if err != nil {
t.Fatalf("Effective : %v", err)
}
expected := PermissionRead | PermissionWrite | PermissionDelete
if permissions != expected {
t.Fatalf("permissions = %d, attendu %d", permissions, expected)
}
}
func TestEffectivePropagationDisabled(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
owner := mustUser(t, service, "owner")
alice := mustUser(t, service, "alice")
root := mustDocument(t, service, owner.ID, nil, "Root", "", true)
child := mustDocument(t, service, owner.ID, &root, "Child", "", true)
if _, err := service.Grant(ctx, GrantParams{
DocumentID: root,
SubjectID: alice.ID,
Permissions: PermissionRead,
Propagate: false,
GrantedBy: owner.ID,
}); err != nil {
t.Fatalf("Grant : %v", err)
}
permissions, err := service.Effective(ctx, alice.ID, child)
if err != nil {
t.Fatalf("Effective : %v", err)
}
if permissions != 0 {
t.Fatalf("permissions = %d, attendu 0", permissions)
}
}
func TestEffectiveAclInheritBreak(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
owner := mustUser(t, service, "owner")
alice := mustUser(t, service, "alice")
root := mustDocument(t, service, owner.ID, nil, "Root", "", true)
middle := mustDocument(t, service, owner.ID, &root, "Middle", "", false)
leaf := mustDocument(t, service, owner.ID, &middle, "Leaf", "", true)
if _, err := service.Grant(ctx, GrantParams{
DocumentID: root,
SubjectID: alice.ID,
Permissions: PermissionRead,
Propagate: true,
GrantedBy: owner.ID,
}); err != nil {
t.Fatalf("Grant(root) : %v", err)
}
permissions, err := service.Effective(ctx, alice.ID, leaf)
if err != nil {
t.Fatalf("Effective : %v", err)
}
if permissions != 0 {
t.Fatalf("permissions = %d, attendu 0", permissions)
}
if _, err := service.Grant(ctx, GrantParams{
DocumentID: leaf,
SubjectID: alice.ID,
Permissions: PermissionWrite,
GrantedBy: owner.ID,
}); err != nil {
t.Fatalf("Grant(leaf) : %v", err)
}
permissions, err = service.Effective(ctx, alice.ID, leaf)
if err != nil {
t.Fatalf("Effective après grant direct : %v", err)
}
if permissions != PermissionWrite {
t.Fatalf("permissions = %d, attendu %d", permissions, PermissionWrite)
}
}
func TestEffectiveExpiredAndRevoked(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
owner := mustUser(t, service, "owner")
alice := mustUser(t, service, "alice")
documentID := mustDocument(t, service, owner.ID, nil, "Photos", "", true)
expiredAt := time.Now().Add(-time.Hour)
if _, err := service.Grant(ctx, GrantParams{
DocumentID: documentID,
SubjectID: alice.ID,
Permissions: PermissionRead,
ExpiresAt: &expiredAt,
GrantedBy: owner.ID,
}); err != nil {
t.Fatalf("Grant expiré : %v", err)
}
permissions, err := service.Effective(ctx, alice.ID, documentID)
if err != nil {
t.Fatalf("Effective : %v", err)
}
if permissions != 0 {
t.Fatalf("permissions = %d, attendu 0", permissions)
}
future := time.Now().Add(time.Hour)
if _, err := service.Grant(ctx, GrantParams{
DocumentID: documentID,
SubjectID: alice.ID,
Permissions: PermissionWrite,
ExpiresAt: &future,
GrantedBy: owner.ID,
}); err != nil {
t.Fatalf("Grant futur : %v", err)
}
permissions, err = service.Effective(ctx, alice.ID, documentID)
if err != nil {
t.Fatalf("Effective : %v", err)
}
if permissions != PermissionWrite {
t.Fatalf("permissions = %d, attendu %d", permissions, PermissionWrite)
}
if err := service.Revoke(ctx, documentID, alice.ID); err != nil {
t.Fatalf("Revoke : %v", err)
}
permissions, err = service.Effective(ctx, alice.ID, documentID)
if err != nil {
t.Fatalf("Effective après révocation : %v", err)
}
if permissions != 0 {
t.Fatalf("permissions = %d, attendu 0", permissions)
}
}
func TestEffectiveVisibility(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
owner := mustUser(t, service, "owner")
alice := mustUser(t, service, "alice")
guest := mustPrincipal(t, service, identity.KindGuest, "jean")
system := mustPrincipal(t, service, identity.KindSystem, "system-test")
clusterDoc := mustDocument(t, service, owner.ID, nil, "Cluster", document.VisibilityCluster, true)
privateDoc := mustDocument(t, service, owner.ID, nil, "Private", document.VisibilityPrivate, true)
publicDoc := mustDocument(t, service, owner.ID, nil, "Public", document.VisibilityPublic, true)
federatedDoc := mustDocument(t, service, owner.ID, nil, "Federated", document.VisibilityFederated, true)
cases := []struct {
name string
principalID ident.UUID
documentID ident.UUID
expected Permission
}{
{"cluster/user", alice.ID, clusterDoc, PermissionRead},
{"cluster/guest", guest.ID, clusterDoc, PermissionRead},
{"cluster/system", system.ID, clusterDoc, 0},
{"private/user", alice.ID, privateDoc, 0},
{"public/system", system.ID, publicDoc, PermissionRead},
{"federated/user", alice.ID, federatedDoc, 0},
}
for _, testCase := range cases {
permissions, err := service.Effective(ctx, testCase.principalID, testCase.documentID)
if err != nil {
t.Fatalf("%s : Effective : %v", testCase.name, err)
}
if permissions != testCase.expected {
t.Fatalf("%s : permissions = %d, attendu %d", testCase.name, permissions, testCase.expected)
}
}
}
func TestEffectiveInactivePrincipal(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
owner := mustUser(t, service, "owner")
alice := mustUser(t, service, "alice")
documentID := mustDocument(t, service, owner.ID, nil, "Photos", "", true)
if _, err := service.Grant(ctx, GrantParams{
DocumentID: documentID,
SubjectID: alice.ID,
Permissions: PermissionRead,
GrantedBy: owner.ID,
}); err != nil {
t.Fatalf("Grant : %v", err)
}
disablePrincipal(t, service, alice.ID)
permissions, err := service.Effective(ctx, alice.ID, documentID)
if err != nil {
t.Fatalf("Effective : %v", err)
}
if permissions != 0 {
t.Fatalf("permissions = %d, attendu 0", permissions)
}
}
func TestEffectiveMissingDocument(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
alice := mustUser(t, service, "alice")
missing, err := ident.NewV7()
if err != nil {
t.Fatalf("NewV7 : %v", err)
}
_, err = service.Effective(ctx, alice.ID, missing)
if !errors.Is(err, ErrDocumentNotFound) {
t.Fatalf("erreur = %v, attendu ErrDocumentNotFound", err)
}
}
+72
View File
@@ -0,0 +1,72 @@
package acl
import (
"context"
"database/sql"
"errors"
"fmt"
"mediarr/database"
"mediarr/ident"
"mediarr/identity"
)
const maxDocumentDepth = 256
type Service struct {
db database.DatabaseClient
identity *identity.Service
}
func NewService(db database.DatabaseClient) *Service {
return &Service{
db: db,
identity: identity.NewService(db),
}
}
func (s *Service) documentChain(ctx context.Context, documentID ident.UUID) ([]database.Document, error) {
chain := make([]database.Document, 0, 8)
seen := make(map[ident.UUID]struct{})
current := documentID
for {
if _, exists := seen[current]; exists {
return nil, ErrDocumentCycle
}
seen[current] = struct{}{}
document, err := s.db.Queries.GetDocument(ctx, current)
if err != nil {
if errors.Is(err, sql.ErrNoRows) {
return nil, fmt.Errorf("%w: %s", ErrDocumentNotFound, current)
}
return nil, err
}
chain = append(chain, document)
if document.ParentID == nil {
return chain, nil
}
if len(chain) >= maxDocumentDepth {
return nil, ErrDocumentCycle
}
current = *document.ParentID
}
}
func (s *Service) loadSubject(ctx context.Context, subjectID ident.UUID) (*identity.Principal, error) {
subject, err := s.identity.GetPrincipal(ctx, subjectID)
if err != nil {
if errors.Is(err, sql.ErrNoRows) {
return nil, fmt.Errorf("%w: %s", ErrSubjectNotFound, subjectID)
}
return nil, err
}
if subject.Status != identity.StatusActive {
return nil, fmt.Errorf("%w: %s", ErrSubjectNotFound, subjectID)
}
return subject, nil
}
+6
View File
@@ -24,6 +24,12 @@ type Account struct {
CreatedAt int64
}
const (
AccountStateActive = "active"
AccountStateLocked = "locked"
AccountStateDisabled = "disabled"
)
var (
ErrInvalidCredentials = errors.New("identifiants invalides")
ErrAccountLocked = errors.New("compte verrouillé")
+6 -5
View File
@@ -12,6 +12,7 @@ import (
"mediarr/database"
"mediarr/ident"
"mediarr/identity"
)
const (
@@ -57,7 +58,7 @@ func (s *Service) CreateSession(ctx context.Context, params CreateSessionParams)
}
return nil, "", err
}
if principal.Status != "active" {
if principal.Status != identity.StatusActive {
return nil, "", ErrInvalidSession
}
@@ -67,10 +68,10 @@ func (s *Service) CreateSession(ctx context.Context, params CreateSessionParams)
switch {
case err == nil:
switch account.State {
case "active":
case "disabled":
case AccountStateActive:
case AccountStateDisabled:
return nil, "", ErrAccountDisabled
case "locked":
case AccountStateLocked:
if !account.LockedUntil.Valid || account.LockedUntil.Int64 > now {
return nil, "", ErrAccountLocked
}
@@ -152,7 +153,7 @@ func (s *Service) ValidateSession(ctx context.Context, token string) (*Session,
}
return nil, nil, err
}
if user.Principal.Status != "active" || user.Account.State == "disabled" {
if user.Principal.Status != identity.StatusActive || user.Account.State == AccountStateDisabled {
return nil, nil, ErrInvalidSession
}
+3 -3
View File
@@ -149,8 +149,8 @@ func TestGuestSession(t *testing.T) {
if authenticated.Account.Login != "jean" {
t.Fatalf("login = %q, attendu jean", authenticated.Account.Login)
}
if authenticated.Account.State != "active" {
t.Fatalf("state = %q, attendu active", authenticated.Account.State)
if authenticated.Account.State != AccountStateActive {
t.Fatalf("state = %q, attendu %q", authenticated.Account.State, AccountStateActive)
}
}
@@ -161,7 +161,7 @@ func TestCreateSessionRejectsInactivePrincipal(t *testing.T) {
created := mustCreateUser(t, service, "alice", "correct horse battery staple", identity.RoleMember)
_, err := service.db.WriteQueries.UpdatePrincipalStatus(ctx, database.UpdatePrincipalStatusParams{
Status: "disabled",
Status: identity.StatusDisabled,
ID: created.Principal.ID,
})
if err != nil {
+8 -8
View File
@@ -70,7 +70,7 @@ func (s *Service) CreateUser(ctx context.Context, params CreateUserParams) (*Aut
ID: userID,
Kind: identity.KindUser,
Name: display,
Status: "active",
Status: identity.StatusActive,
CreatedAt: now,
}); err != nil {
return err
@@ -89,7 +89,7 @@ func (s *Service) CreateUser(ctx context.Context, params CreateUserParams) (*Aut
Valid: true,
},
MustChangePassword: 0,
State: "active",
State: AccountStateActive,
FailedAttempts: 0,
CreatedAt: now,
}); err != nil {
@@ -135,23 +135,23 @@ func (s *Service) Authenticate(ctx context.Context, login, password string) (*Au
}
return nil, err
}
if principal.Status != "active" {
if principal.Status != identity.StatusActive {
return nil, ErrInvalidCredentials
}
now := time.Now().UnixMilli()
switch account.State {
case "disabled":
case AccountStateDisabled:
return nil, ErrAccountDisabled
case "locked":
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 = "active"
account.State = AccountStateActive
account.FailedAttempts = 0
account.LockedUntil = sql.NullInt64{}
}
@@ -177,7 +177,7 @@ func (s *Service) Authenticate(ctx context.Context, login, password string) (*Au
if err != nil {
return nil, err
}
if updated.State == "locked" {
if updated.State == AccountStateLocked {
return nil, ErrAccountLocked
}
return nil, ErrInvalidCredentials
@@ -241,7 +241,7 @@ func (s *Service) loadAuthenticatedUser(ctx context.Context, id ident.UUID) (*Au
Account: Account{
PrincipalID: id,
Login: principal.Name,
State: "active",
State: AccountStateActive,
},
}, nil
default:
+9 -9
View File
@@ -32,11 +32,11 @@ func TestCreateUser(t *testing.T) {
if created.Principal.Name != "Alice" {
t.Fatalf("name = %q, attendu Alice", created.Principal.Name)
}
if created.Principal.Status != "active" {
t.Fatalf("status = %q, attendu active", created.Principal.Status)
if created.Principal.Status != identity.StatusActive {
t.Fatalf("status = %q, attendu %q", created.Principal.Status, identity.StatusActive)
}
if created.Account.State != "active" {
t.Fatalf("état du compte = %q, attendu active", created.Account.State)
if created.Account.State != AccountStateActive {
t.Fatalf("état du compte = %q, attendu %q", created.Account.State, AccountStateActive)
}
if len(created.Principal.Groups) != 1 || created.Principal.Groups[0].Name != "members" {
t.Fatalf("groupes = %+v, attendu members", created.Principal.Groups)
@@ -198,8 +198,8 @@ func TestAuthenticateLocksAccountAfterTooManyFailures(t *testing.T) {
if err != nil {
t.Fatalf("GetAccount : %v", err)
}
if account.State != "locked" {
t.Fatalf("state = %q, attendu locked", account.State)
if account.State != AccountStateLocked {
t.Fatalf("state = %q, attendu %q", account.State, AccountStateLocked)
}
if !account.LockedUntil.Valid || account.LockedUntil.Int64 <= time.Now().UnixMilli() {
t.Fatalf("locked_until = %+v, attendu dans le futur", account.LockedUntil)
@@ -232,8 +232,8 @@ func TestAuthenticateUnlocksExpiredAccount(t *testing.T) {
if err != nil {
t.Fatalf("GetAccount : %v", err)
}
if account.State != "active" {
t.Fatalf("state = %q, attendu active", account.State)
if account.State != AccountStateActive {
t.Fatalf("state = %q, attendu %q", account.State, AccountStateActive)
}
if account.FailedAttempts != 0 {
t.Fatalf("failed_attempts = %d, attendu 0", account.FailedAttempts)
@@ -247,7 +247,7 @@ func TestAuthenticateRejectsDisabledAccount(t *testing.T) {
created := mustCreateUser(t, service, "alice", "correct horse battery staple", identity.RoleMember)
_, err := service.db.WriteQueries.UpdateAccountState(ctx, database.UpdateAccountStateParams{
State: "disabled",
State: AccountStateDisabled,
PrincipalID: created.Principal.ID,
})
if err != nil {
+199 -5
View File
@@ -398,6 +398,45 @@ func (q *Queries) GetClusterPrincipal(ctx context.Context) (Principal, error) {
return i, err
}
const getDocument = `-- name: GetDocument :one
SELECT id, kind, owner_id, created_by, parent_id, name, name_key, path, depth, position, head_version_id, metadata, policy_id, visibility, acl_inherit, rev, created_at, updated_at, deleted_at, deleted_by, trash_batch
FROM document
WHERE id = ?1
`
// ============================================================================
// document
// ============================================================================
func (q *Queries) GetDocument(ctx context.Context, id ident.UUID) (Document, error) {
row := q.db.QueryRowContext(ctx, getDocument, id)
var i Document
err := row.Scan(
&i.ID,
&i.Kind,
&i.OwnerID,
&i.CreatedBy,
&i.ParentID,
&i.Name,
&i.NameKey,
&i.Path,
&i.Depth,
&i.Position,
&i.HeadVersionID,
&i.Metadata,
&i.PolicyID,
&i.Visibility,
&i.AclInherit,
&i.Rev,
&i.CreatedAt,
&i.UpdatedAt,
&i.DeletedAt,
&i.DeletedBy,
&i.TrashBatch,
)
return i, err
}
const getMembership = `-- name: GetMembership :one
SELECT group_id, member_id, role, created_at
FROM membership
@@ -572,6 +611,53 @@ func (q *Queries) IncrementFailedAttempts(ctx context.Context, principalID ident
return i, err
}
const listActiveACLEntriesForDocument = `-- name: ListActiveACLEntriesForDocument :many
SELECT id, document_id, subject_id, permissions, propagate, expires_at, granted_by, created_at, revoked_at
FROM acl_entry
WHERE document_id = ?1
AND revoked_at IS NULL
AND (expires_at IS NULL OR expires_at > CAST(?2 AS INTEGER))
ORDER BY created_at
`
type ListActiveACLEntriesForDocumentParams struct {
DocumentID ident.UUID
Now int64
}
func (q *Queries) ListActiveACLEntriesForDocument(ctx context.Context, arg ListActiveACLEntriesForDocumentParams) ([]AclEntry, error) {
rows, err := q.db.QueryContext(ctx, listActiveACLEntriesForDocument, arg.DocumentID, arg.Now)
if err != nil {
return nil, err
}
defer rows.Close()
var items []AclEntry
for rows.Next() {
var i AclEntry
if err := rows.Scan(
&i.ID,
&i.DocumentID,
&i.SubjectID,
&i.Permissions,
&i.Propagate,
&i.ExpiresAt,
&i.GrantedBy,
&i.CreatedAt,
&i.RevokedAt,
); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Close(); err != nil {
return nil, err
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const listActivePrincipals = `-- name: ListActivePrincipals :many
SELECT id, kind, name, public_key, status, successor_id, created_at, disabled_at
FROM principal
@@ -735,7 +821,7 @@ func (q *Queries) ListMemberGroups(ctx context.Context, memberID ident.UUID) ([]
}
const listMemberGroupsWithRole = `-- name: ListMemberGroupsWithRole :many
SELECT p.id, p.name, m.role
SELECT p.id, p.name, p.status, m.role
FROM membership m
JOIN principal p ON p.id = m.group_id
WHERE m.member_id = ?1
@@ -743,9 +829,10 @@ ORDER BY p.name
`
type ListMemberGroupsWithRoleRow struct {
ID ident.UUID
Name string
Role string
ID ident.UUID
Name string
Status string
Role string
}
func (q *Queries) ListMemberGroupsWithRole(ctx context.Context, memberID ident.UUID) ([]ListMemberGroupsWithRoleRow, error) {
@@ -757,7 +844,12 @@ func (q *Queries) ListMemberGroupsWithRole(ctx context.Context, memberID ident.U
var items []ListMemberGroupsWithRoleRow
for rows.Next() {
var i ListMemberGroupsWithRoleRow
if err := rows.Scan(&i.ID, &i.Name, &i.Role); err != nil {
if err := rows.Scan(
&i.ID,
&i.Name,
&i.Status,
&i.Role,
); err != nil {
return nil, err
}
items = append(items, i)
@@ -1093,6 +1185,38 @@ func (q *Queries) ResetFailedAttempts(ctx context.Context, principalID ident.UUI
return i, err
}
const revokeACLEntry = `-- name: RevokeACLEntry :one
UPDATE acl_entry
SET revoked_at = ?1
WHERE document_id = ?2
AND subject_id = ?3
AND revoked_at IS NULL
RETURNING id, document_id, subject_id, permissions, propagate, expires_at, granted_by, created_at, revoked_at
`
type RevokeACLEntryParams struct {
RevokedAt sql.NullInt64
DocumentID ident.UUID
SubjectID ident.UUID
}
func (q *Queries) RevokeACLEntry(ctx context.Context, arg RevokeACLEntryParams) (AclEntry, error) {
row := q.db.QueryRowContext(ctx, revokeACLEntry, arg.RevokedAt, arg.DocumentID, arg.SubjectID)
var i AclEntry
err := row.Scan(
&i.ID,
&i.DocumentID,
&i.SubjectID,
&i.Permissions,
&i.Propagate,
&i.ExpiresAt,
&i.GrantedBy,
&i.CreatedAt,
&i.RevokedAt,
)
return i, err
}
const revokeSession = `-- name: RevokeSession :one
UPDATE session
SET revoked_at = ?1
@@ -1425,3 +1549,73 @@ func (q *Queries) UpdatePrincipalSuccessor(ctx context.Context, arg UpdatePrinci
)
return i, err
}
const upsertACLEntry = `-- name: UpsertACLEntry :one
INSERT INTO acl_entry (
id,
document_id,
subject_id,
permissions,
propagate,
expires_at,
granted_by,
created_at
) VALUES (
?1,
?2,
?3,
?4,
?5,
?6,
?7,
?8
)
ON CONFLICT(document_id, subject_id) DO UPDATE SET
permissions = excluded.permissions,
propagate = excluded.propagate,
expires_at = excluded.expires_at,
granted_by = excluded.granted_by,
revoked_at = NULL
RETURNING id, document_id, subject_id, permissions, propagate, expires_at, granted_by, created_at, revoked_at
`
type UpsertACLEntryParams struct {
ID ident.UUID
DocumentID ident.UUID
SubjectID ident.UUID
Permissions int64
Propagate int64
ExpiresAt sql.NullInt64
GrantedBy ident.UUID
CreatedAt int64
}
// ============================================================================
// acl_entry
// ============================================================================
func (q *Queries) UpsertACLEntry(ctx context.Context, arg UpsertACLEntryParams) (AclEntry, error) {
row := q.db.QueryRowContext(ctx, upsertACLEntry,
arg.ID,
arg.DocumentID,
arg.SubjectID,
arg.Permissions,
arg.Propagate,
arg.ExpiresAt,
arg.GrantedBy,
arg.CreatedAt,
)
var i AclEntry
err := row.Scan(
&i.ID,
&i.DocumentID,
&i.SubjectID,
&i.Permissions,
&i.Propagate,
&i.ExpiresAt,
&i.GrantedBy,
&i.CreatedAt,
&i.RevokedAt,
)
return i, err
}
+58 -1
View File
@@ -155,7 +155,7 @@ WHERE group_id = sqlc.arg(group_id)
AND member_id = sqlc.arg(member_id);
-- name: ListMemberGroupsWithRole :many
SELECT p.id, p.name, m.role
SELECT p.id, p.name, p.status, m.role
FROM membership m
JOIN principal p ON p.id = m.group_id
WHERE m.member_id = sqlc.arg(member_id)
@@ -351,3 +351,60 @@ ORDER BY created_at DESC;
DELETE FROM session
WHERE expires_at <= sqlc.arg(now)
OR idle_expires_at <= sqlc.arg(now);
-- ============================================================================
-- document
-- ============================================================================
-- name: GetDocument :one
SELECT *
FROM document
WHERE id = sqlc.arg(id);
-- ============================================================================
-- acl_entry
-- ============================================================================
-- name: UpsertACLEntry :one
INSERT INTO acl_entry (
id,
document_id,
subject_id,
permissions,
propagate,
expires_at,
granted_by,
created_at
) VALUES (
sqlc.arg(id),
sqlc.arg(document_id),
sqlc.arg(subject_id),
sqlc.arg(permissions),
sqlc.arg(propagate),
sqlc.narg(expires_at),
sqlc.arg(granted_by),
sqlc.arg(created_at)
)
ON CONFLICT(document_id, subject_id) DO UPDATE SET
permissions = excluded.permissions,
propagate = excluded.propagate,
expires_at = excluded.expires_at,
granted_by = excluded.granted_by,
revoked_at = NULL
RETURNING *;
-- name: RevokeACLEntry :one
UPDATE acl_entry
SET revoked_at = sqlc.arg(revoked_at)
WHERE document_id = sqlc.arg(document_id)
AND subject_id = sqlc.arg(subject_id)
AND revoked_at IS NULL
RETURNING *;
-- name: ListActiveACLEntriesForDocument :many
SELECT *
FROM acl_entry
WHERE document_id = sqlc.arg(document_id)
AND revoked_at IS NULL
AND (expires_at IS NULL OR expires_at > CAST(sqlc.arg(now) AS INTEGER))
ORDER BY created_at;
+7
View File
@@ -1,5 +1,12 @@
package document
const (
VisibilityPrivate = "PRIVATE"
VisibilityCluster = "CLUSTER"
VisibilityFederated = "FEDERATED"
VisibilityPublic = "PUBLIC"
)
type Document struct {
Kind string
Hidden string
+4 -3
View File
@@ -95,9 +95,10 @@ func (s *Service) ListGroups(ctx context.Context, memberID ident.UUID) ([]Group,
groups := make([]Group, 0, len(rows))
for _, row := range rows {
groups = append(groups, Group{
ID: row.ID,
Name: row.Name,
Role: row.Role,
ID: row.ID,
Name: row.Name,
Status: row.Status,
Role: row.Role,
})
}
+10 -3
View File
@@ -19,6 +19,12 @@ const (
RoleMember = "member"
)
const (
StatusActive = "active"
StatusDisabled = "disabled"
StatusRevoked = "revoked"
)
type Principal struct {
ID ident.UUID
Kind string
@@ -29,9 +35,10 @@ type Principal struct {
}
type Group struct {
ID ident.UUID
Name string
Role string
ID ident.UUID
Name string
Status string
Role string
}
type Member struct {
+5 -3
View File
@@ -31,9 +31,11 @@ func (s *Service) CreatePrincipal(ctx context.Context, params CreatePrincipalPar
status := params.Status
if status == "" {
status = "active"
status = StatusActive
}
if status != "active" && status != "disabled" && status != "revoked" {
switch status {
case StatusActive, StatusDisabled, StatusRevoked:
default:
return nil, fmt.Errorf("%w: %q", ErrInvalidStatus, status)
}
@@ -87,7 +89,7 @@ func (s *Service) CreateGuest(ctx context.Context, name string) (*Principal, err
ID: id,
Kind: KindGuest,
Name: name,
Status: "active",
Status: StatusActive,
CreatedAt: now,
}); err != nil {
return err
+2 -2
View File
@@ -27,8 +27,8 @@ func TestCreatePrincipal(t *testing.T) {
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.Status != StatusActive {
t.Fatalf("status = %q, attendu %q", created.Status, StatusActive)
}
if len(created.Groups) != 0 {
t.Fatalf("groupes = %+v, attendu aucun", created.Groups)
+5
View File
@@ -1,6 +1,7 @@
package node
import (
"mediarr/acl"
"mediarr/auth"
"mediarr/cluster"
"mediarr/database"
@@ -59,3 +60,7 @@ func (n *Node) Identity() *identity.Service {
func (n *Node) Auth() *auth.Service {
return auth.NewService(n.db)
}
func (n *Node) ACL() *acl.Service {
return acl.NewService(n.db)
}
+14 -13
View File
@@ -9,6 +9,7 @@ import (
"mediarr/cluster"
"mediarr/database"
"mediarr/ident"
"mediarr/identity"
"time"
)
@@ -42,20 +43,20 @@ func (n *Node) ensureClusterIdentity(ctx context.Context) error {
switch {
case err == nil:
identity, loadErr := cluster.LoadOrCreate(n.clusterKeyPath, false)
clusterIdentity, loadErr := cluster.LoadOrCreate(n.clusterKeyPath, false)
if loadErr != nil {
return fmt.Errorf("cluster : principal présent en base mais clé indisponible : %w", loadErr)
}
if !bytes.Equal(principal.PublicKey, identity.PublicKey) {
if !bytes.Equal(principal.PublicKey, clusterIdentity.PublicKey) {
return errors.New("cluster : la clé publique de cluster.key ne correspond pas au principal en base")
}
n.cluster = identity
n.cluster = clusterIdentity
return nil
case errors.Is(err, sql.ErrNoRows):
identity, createErr := cluster.LoadOrCreate(n.clusterKeyPath, true)
clusterIdentity, createErr := cluster.LoadOrCreate(n.clusterKeyPath, true)
if createErr != nil {
return createErr
}
@@ -69,21 +70,21 @@ func (n *Node) ensureClusterIdentity(ctx context.Context) error {
ID: clusterID,
Kind: "cluster",
Name: "cluster",
PublicKey: identity.PublicKeyBytes(),
Status: "active",
PublicKey: clusterIdentity.PublicKeyBytes(),
Status: identity.StatusActive,
CreatedAt: time.Now().UnixMilli(),
})
if createErr != nil {
existing, getErr := n.db.Queries.GetClusterPrincipal(ctx)
if getErr == nil && bytes.Equal(existing.PublicKey, identity.PublicKey) {
n.cluster = identity
if getErr == nil && bytes.Equal(existing.PublicKey, clusterIdentity.PublicKey) {
n.cluster = clusterIdentity
return nil
}
return fmt.Errorf("cluster : création du principal : %w", createErr)
}
n.cluster = identity
n.cluster = clusterIdentity
return nil
default:
@@ -99,28 +100,28 @@ func requiredNodePrincipals(now int64) []database.CreatePrincipalParams {
ID: ident.MustParse("00000000-0000-7000-8000-000000000001"),
Kind: "system",
Name: "system",
Status: "active",
Status: identity.StatusActive,
CreatedAt: now,
},
{
ID: ident.MustParse("00000000-0000-7000-8000-000000000002"),
Kind: "group",
Name: "admins",
Status: "active",
Status: identity.StatusActive,
CreatedAt: now,
},
{
ID: ident.MustParse("00000000-0000-7000-8000-000000000003"),
Kind: "group",
Name: "members",
Status: "active",
Status: identity.StatusActive,
CreatedAt: now,
},
{
ID: ident.MustParse("00000000-0000-7000-8000-000000000004"),
Kind: "group",
Name: "guests",
Status: "active",
Status: identity.StatusActive,
CreatedAt: now,
},
}
+6 -5
View File
@@ -8,6 +8,7 @@ import (
"testing"
"mediarr/cluster"
"mediarr/identity"
)
func TestUpCreatesAndKeepsClusterIdentity(t *testing.T) {
@@ -25,9 +26,9 @@ func TestUpCreatesAndKeepsClusterIdentity(t *testing.T) {
t.Fatalf("Up : %v", err)
}
identity := node.ClusterIdentity()
if len(identity.PublicKey) != 32 {
t.Fatalf("clé publique de %d octets, attendu 32", len(identity.PublicKey))
clusterIdentity := node.ClusterIdentity()
if len(clusterIdentity.PublicKey) != 32 {
t.Fatalf("clé publique de %d octets, attendu 32", len(clusterIdentity.PublicKey))
}
principal, err := node.db.Queries.GetClusterPrincipal(context.Background())
@@ -40,10 +41,10 @@ func TestUpCreatesAndKeepsClusterIdentity(t *testing.T) {
if principal.Name != "cluster" {
t.Fatalf("name = %q, attendu cluster", principal.Name)
}
if principal.Status != "active" {
if principal.Status != identity.StatusActive {
t.Fatalf("status = %q, attendu active", principal.Status)
}
if !bytes.Equal(principal.PublicKey, identity.PublicKey) {
if !bytes.Equal(principal.PublicKey, clusterIdentity.PublicKey) {
t.Fatal("la clé publique en base ne correspond pas à la clé chargée")
}