generate identity

This commit is contained in:
venture
2026-11-13 21:49:09 +01:00
parent 4da2fe9424
commit 7ebe8962dd
9 changed files with 689 additions and 5 deletions
+2
View File
@@ -1,3 +1,5 @@
*.db *.db
*.db-wal *.db-wal
*.db-shm *.db-shm
*.key
.cluster-key-*
+73
View File
@@ -0,0 +1,73 @@
Oui, l’idée est bonne, avec une nuance importante :
- Cluster = un domaine de confiance (une racine d’identité), composé d’un ou plusieurs nœuds. Les nœuds sont les membres ; le cluster est l’ensemble.
- Fédération = relation de confiance entre plusieurs clusters (plusieurs racines distinctes), pas entre nœuds isolés.
Unité
Identité
But
Clés privées
Exemple :
- Cluster A : racine A, nœuds A1, A2.
- Cluster B : racine B, nœuds B1, B2.
- Fédération A↔B : A1 peut voir certains documents de B, selon un accord signé et des politiques. Mais A et B restent deux clusters distincts, avec leurs propres racines, ACL et gouvernance.
Donc :
- un cluster peut n’avoir qu’un seul nœud ;
- une fédération implique au moins deux clusters ;
- des nœuds de clusters différents ne deviennent pas un seul cluster : ils restent séparés et se parlent via la fédération.
Dans le schéma MediarrV2, visibility = 'FEDERATED' correspond à ce second niveau : un document partageable hors du cluster, pas simplement entre nœuds du même cluster.
# Exmple concrait
Prenons un exemple concret, type Mediarr familial.
Le décor
Cluster « Maison » (racine M) :
- nœuds : hub-maison (toujours allumé), nas-maison, portable-papa
- utilisateurs : papa, maman, enfant
- bibliothèques : Films, Photos, Vacances
Cluster « Amis » (racine A) :
- nœuds : hub-ami, portable-jean
- utilisateurs : jean, groupe-proches
- bibliothèques : Films-Amis, Photos-Amis
1. Dans un cluster : coordonner, répliquer, partager les ACL
Ce que tu peux faire
- Coordonner : papa ajoute Film.mp4 sur portable-papa. Le portable pousse la version au hub-maison, qui attribue le seq et met à jour head_version_id. Les autres nœuds du cluster voient la même arborescence.
- Répliquer : le hub-maison réplique le blob vers nas-maison. Si le NAS est éteint, il rattrape plus tard. La politique de stockage (min_remote_replicas) s’applique à l’intérieur du cluster.
- Partager les ACL : un ACL donne READ au groupe enfant sur Photos. Comme tous les nœuds partagent les mêmes principal.id et la même racine M, l’ACL est comprise et appliquée de la même façon sur hub-maison, nas-maison et portable-papa.
- Cohérence : déplacer un document, restaurer depuis la corbeille, changer une ACL, résoudre un conflit de version : tout cela reste dans le même domaine de confiance.
- Identité : papa peut se connecter sur n’importe quel nœud du cluster et retrouver ses droits.
Ce que tu ne peux pas faire
- Prendre un nœud avec une autre clé racine et le considérer comme membre du cluster. Il formerait un autre cluster.
- Utiliser une adresse IP comme identité de nœud. L’IP peut changer, le cluster s’appuie sur les clés/identités.
- Donner accès à Vacances à jean (utilisateur du cluster Amis) comme s’il était un utilisateur local. Sans fédération, jean n’existe pas dans le cluster Maison.
- Fusionner les bases ou les annuaires des deux clusters.
2. En fédération : échanger/partager entre clusters, avec politiques
La fédération commence par un accord de confiance : Maison et Amis échangent leurs clés publiques de cluster et signent un contrat de fédération.
Exemple d’accord :
- Maison partage la bibliothèque Vacances avec le cluster Amis.
- Visibilité : FEDERATED.
- Sujet distant autorisé : groupe-proches (côté Amis) → READ.
- Expiration : 31/12/2026.
- Pas d’écriture, pas d’accès aux autres bibliothèques.
- Cache/relais autorisés selon la politique.
Ce que tu peux faire
- jean (dans groupe-proches) voit Vacances depuis hub-ami, sans devenir un utilisateur local de Maison.
- Maison peut révoquer l’accès ou changer l’expiration ; Amis doit re-vérifier.
- Amis peut mettre en cache les métadonnées/contenus autorisés, selon la politique de fédération.
- Chaque cluster garde sa propre racine, ses utilisateurs, ses ACL internes et sa gouvernance.
- On peut partager une partie seulement (une bibliothèque, une collection), pas tout le cluster.
Ce que tu ne peux pas faire
- jean ne peut pas obtenir ADMIN sur Vacances sauf si Maison l’accorde explicitement.
- jean ne peut pas voir Films ou Photos si ces bibliothèques ne sont pas partagées.
- Amis ne peut pas modifier les ACL internes de Maison, ni utiliser la clé privée M.
- Amis ne peut pas forcer Maison à stocker ses blobs, ni fusionner les deux bases.
- On ne peut pas supposer qu’un utilisateur Amis est automatiquement le même que quelqu’un de Maison : il faut un mapping d’identité explicite.
- Une fédération n’est pas une fusion : les clusters restent souverains.
Et vice versa
- Amis peut partager Photos-Amis avec Maison, avec ses propres règles.
- Maison ne voit pas Films-Amis tant qu’Amis ne l’a pas partagé.
- Chaque cluster peut couper la fédération unilatéralement.
Règle simple
- Cluster = « chez moi » : je coordonne mes nœuds, je réplique mes données, j’applique mes ACL partout dans mon domaine.
- Fédération = « pont entre chez moi et chez toi » : je partage ce que je choisis, avec qui je choisis, selon des règles et une durée, sans fusionner nos identités ni nos clés.
Dans le schéma, visibility = 'FEDERATED' et les futures tables document_remote, share_link, etc. servent à matérialiser ce second niveau. Le cluster reste le domaine de confiance de base.
+192
View File
@@ -0,0 +1,192 @@
package cluster
import (
"crypto/ed25519"
"crypto/rand"
"crypto/x509"
"encoding/pem"
"errors"
"fmt"
"os"
"path/filepath"
)
const privateKeyPEMType = "PRIVATE KEY"
// Identity est l'identité racine du cluster. La clé privée ne doit jamais
// être persistée en base ni journalisée.
type Identity struct {
PrivateKey ed25519.PrivateKey
PublicKey ed25519.PublicKey
Path string
}
// LoadOrCreate charge la clé privée PKCS#8 PEM présente dans path. Si elle
// n'existe pas et que allowCreate est vrai, une nouvelle paire Ed25519 est
// générée et écrite avec les permissions 0600.
func LoadOrCreate(path string, allowCreate bool) (Identity, error) {
if path == "" {
return Identity{}, errors.New("cluster : chemin de clé vide")
}
identity, err := load(path)
if err == nil {
return identity, nil
}
if !errors.Is(err, os.ErrNotExist) {
return Identity{}, err
}
if !allowCreate {
return Identity{}, fmt.Errorf("cluster : clé absente (%s) et création désactivée", path)
}
return create(path)
}
func load(path string) (Identity, error) {
info, err := os.Lstat(path)
if err != nil {
return Identity{}, err
}
if info.Mode()&os.ModeSymlink != 0 {
return Identity{}, fmt.Errorf("cluster : %s est un lien symbolique, refusé", path)
}
if !info.Mode().IsRegular() {
return Identity{}, fmt.Errorf("cluster : %s n'est pas un fichier régulier", path)
}
if info.Mode().Perm()&0o077 != 0 {
return Identity{}, fmt.Errorf(
"cluster : permissions trop larges sur %s (%04o), attendu 0600",
path,
info.Mode().Perm(),
)
}
data, err := os.ReadFile(path)
if err != nil {
return Identity{}, err
}
block, _ := pem.Decode(data)
if block == nil {
return Identity{}, fmt.Errorf("cluster : %s ne contient pas de PEM valide", path)
}
if block.Type != privateKeyPEMType {
return Identity{}, fmt.Errorf("cluster : type PEM %q inattendu", block.Type)
}
parsed, err := x509.ParsePKCS8PrivateKey(block.Bytes)
if err != nil {
return Identity{}, fmt.Errorf("cluster : clé PKCS#8 invalide : %w", err)
}
privateKey, ok := parsed.(ed25519.PrivateKey)
if !ok {
return Identity{}, fmt.Errorf("cluster : clé de type %T, attendu ed25519.PrivateKey", parsed)
}
publicKey, ok := privateKey.Public().(ed25519.PublicKey)
if !ok {
return Identity{}, errors.New("cluster : clé publique Ed25519 invalide")
}
return Identity{
PrivateKey: privateKey,
PublicKey: publicKey,
Path: path,
}, nil
}
func create(path string) (Identity, error) {
publicKey, privateKey, err := ed25519.GenerateKey(rand.Reader)
if err != nil {
return Identity{}, fmt.Errorf("cluster : génération de clé : %w", err)
}
der, err := x509.MarshalPKCS8PrivateKey(privateKey)
if err != nil {
return Identity{}, fmt.Errorf("cluster : encodage PKCS#8 : %w", err)
}
data := pem.EncodeToMemory(&pem.Block{Type: privateKeyPEMType, Bytes: der})
if data == nil {
return Identity{}, errors.New("cluster : encodage PEM")
}
dir := filepath.Dir(path)
if dir == "" {
dir = "."
}
if dir != "." {
if err := os.MkdirAll(dir, 0o700); err != nil {
return Identity{}, fmt.Errorf("cluster : création du répertoire %s : %w", dir, err)
}
}
temp, err := os.CreateTemp(dir, ".cluster-key-*")
if err != nil {
return Identity{}, fmt.Errorf("cluster : création du fichier temporaire : %w", err)
}
tempPath := temp.Name()
cleanup := func() {
_ = temp.Close()
_ = os.Remove(tempPath)
}
if err := temp.Chmod(0o600); err != nil {
cleanup()
return Identity{}, fmt.Errorf("cluster : permissions du fichier temporaire : %w", err)
}
written, writeErr := temp.Write(data)
if writeErr != nil || written != len(data) {
cleanup()
if writeErr != nil {
return Identity{}, fmt.Errorf("cluster : écriture de %s : %w", tempPath, writeErr)
}
return Identity{}, fmt.Errorf("cluster : écriture partielle de %s", tempPath)
}
if err := temp.Sync(); err != nil {
cleanup()
return Identity{}, fmt.Errorf("cluster : synchronisation de %s : %w", tempPath, err)
}
if err := temp.Close(); err != nil {
_ = os.Remove(tempPath)
return Identity{}, fmt.Errorf("cluster : fermeture de %s : %w", tempPath, err)
}
// Link est atomique et échoue si path existe déjà : on ne peut pas écraser
// une clé créée par un autre processus.
if err := os.Link(tempPath, path); err != nil {
_ = os.Remove(tempPath)
if errors.Is(err, os.ErrExist) {
return load(path)
}
return Identity{}, fmt.Errorf("cluster : installation de %s : %w", path, err)
}
_ = os.Remove(tempPath)
return Identity{
PrivateKey: privateKey,
PublicKey: publicKey,
Path: path,
}, nil
}
func (i Identity) PublicKeyBytes() []byte {
return append([]byte(nil), i.PublicKey...)
}
+148
View File
@@ -0,0 +1,148 @@
package cluster
import (
"bytes"
"os"
"path/filepath"
"sync"
"testing"
)
func TestLoadOrCreateGeneratesAndReloads(t *testing.T) {
path := filepath.Join(t.TempDir(), "cluster.key")
first, err := LoadOrCreate(path, true)
if err != nil {
t.Fatalf("LoadOrCreate (création) : %v", err)
}
info, err := os.Stat(path)
if err != nil {
t.Fatalf("Stat : %v", err)
}
if got := info.Mode().Perm(); got != 0o600 {
t.Fatalf("permissions = %04o, attendu 0600", got)
}
second, err := LoadOrCreate(path, true)
if err != nil {
t.Fatalf("LoadOrCreate (relecture) : %v", err)
}
if !bytes.Equal(first.PublicKey, second.PublicKey) {
t.Fatal("clés publiques différentes après relecture")
}
if !bytes.Equal(first.PrivateKey, second.PrivateKey) {
t.Fatal("clés privées différentes après relecture")
}
}
func TestLoadOrCreateNoCreate(t *testing.T) {
path := filepath.Join(t.TempDir(), "missing.key")
if _, err := LoadOrCreate(path, false); err == nil {
t.Fatal("LoadOrCreate aurait dû échouer sans création autorisée")
}
if _, err := os.Stat(path); !os.IsNotExist(err) {
t.Fatalf("le fichier ne devrait pas exister : %v", err)
}
}
func TestLoadOrCreateCorrupt(t *testing.T) {
path := filepath.Join(t.TempDir(), "cluster.key")
if err := os.WriteFile(path, []byte("pas une clé"), 0o600); err != nil {
t.Fatal(err)
}
if _, err := LoadOrCreate(path, true); err == nil {
t.Fatal("LoadOrCreate aurait dû refuser un fichier corrompu")
}
data, err := os.ReadFile(path)
if err != nil {
t.Fatal(err)
}
if string(data) != "pas une clé" {
t.Fatal("le fichier corrompu a été modifié")
}
}
func TestLoadOrCreateRejectsLoosePermissions(t *testing.T) {
path := filepath.Join(t.TempDir(), "cluster.key")
if _, err := LoadOrCreate(path, true); err != nil {
t.Fatal(err)
}
if err := os.Chmod(path, 0o644); err != nil {
t.Fatal(err)
}
if _, err := LoadOrCreate(path, true); err == nil {
t.Fatal("LoadOrCreate aurait dû refuser des permissions 0644")
}
}
func TestLoadOrCreateRejectsSymlink(t *testing.T) {
dir := t.TempDir()
target := filepath.Join(dir, "target.key")
link := filepath.Join(dir, "cluster.key")
if _, err := LoadOrCreate(target, true); err != nil {
t.Fatal(err)
}
if err := os.Symlink(target, link); err != nil {
t.Skipf("symlink non supporté : %v", err)
}
if _, err := LoadOrCreate(link, true); err == nil {
t.Fatal("LoadOrCreate aurait dû refuser un lien symbolique")
}
}
func TestLoadOrCreateConcurrent(t *testing.T) {
path := filepath.Join(t.TempDir(), "cluster.key")
const goroutines = 16
type result struct {
identity Identity
err error
}
results := make(chan result, goroutines)
var waitGroup sync.WaitGroup
for range goroutines {
waitGroup.Add(1)
go func() {
defer waitGroup.Done()
identity, err := LoadOrCreate(path, true)
results <- result{identity: identity, err: err}
}()
}
waitGroup.Wait()
close(results)
var expected []byte
for current := range results {
if current.err != nil {
t.Fatalf("LoadOrCreate concurrent : %v", current.err)
}
publicKey := current.identity.PublicKeyBytes()
if expected == nil {
expected = publicKey
continue
}
if !bytes.Equal(expected, publicKey) {
t.Fatal("deux processus concurrents ont obtenu des clés différentes")
}
}
}
+23
View File
@@ -282,6 +282,29 @@ func (q *Queries) GetAccountByLoginKey(ctx context.Context, loginKey string) (Ac
return i, err return i, err
} }
const getClusterPrincipal = `-- name: GetClusterPrincipal :one
SELECT id, kind, name, public_key, status, successor_id, created_at, disabled_at
FROM principal
WHERE kind = 'cluster'
LIMIT 1
`
func (q *Queries) GetClusterPrincipal(ctx context.Context) (Principal, error) {
row := q.db.QueryRowContext(ctx, getClusterPrincipal)
var i Principal
err := row.Scan(
&i.ID,
&i.Kind,
&i.Name,
&i.PublicKey,
&i.Status,
&i.SuccessorID,
&i.CreatedAt,
&i.DisabledAt,
)
return i, err
}
const getMembership = `-- name: GetMembership :one const getMembership = `-- name: GetMembership :one
SELECT group_id, member_id, role, created_at SELECT group_id, member_id, role, created_at
FROM membership FROM membership
+6
View File
@@ -40,6 +40,12 @@ FROM principal
WHERE kind = sqlc.arg(kind) WHERE kind = sqlc.arg(kind)
AND name = sqlc.arg(name); AND name = sqlc.arg(name);
-- name: GetClusterPrincipal :one
SELECT *
FROM principal
WHERE kind = 'cluster'
LIMIT 1;
-- name: ListPrincipals :many -- name: ListPrincipals :many
SELECT * SELECT *
FROM principal FROM principal
+20 -1
View File
@@ -1,32 +1,51 @@
package node package node
import ( import (
"mediarr/cluster"
"mediarr/database" "mediarr/database"
) )
type Node struct { type Node struct {
db database.DatabaseClient db database.DatabaseClient
clusterKeyPath string
cluster cluster.Identity
} }
type NewNodeParams struct { type NewNodeParams struct {
DatabaseName string DatabaseName string
ClusterKeyPath string
} }
func NewNode(params NewNodeParams) (error, Node) { func NewNode(params NewNodeParams) (error, Node) {
var databaseName *string
if params.DatabaseName != "" {
databaseName = &params.DatabaseName
}
err, db := database.NewDatabase(database.NewDatabaseParams{ err, db := database.NewDatabase(database.NewDatabaseParams{
DatabaseName: &params.DatabaseName, DatabaseName: databaseName,
}) })
if err != nil { if err != nil {
return err, Node{} return err, Node{}
} }
clusterKeyPath := params.ClusterKeyPath
if clusterKeyPath == "" {
clusterKeyPath = "cluster.key"
}
return nil, Node{ return nil, Node{
db: *db, db: *db,
clusterKeyPath: clusterKeyPath,
} }
} }
func (n *Node) Close() error { func (n *Node) Close() error {
return n.db.Close() return n.db.Close()
} }
func (n *Node) ClusterIdentity() cluster.Identity {
return n.cluster
}
+59
View File
@@ -1,9 +1,12 @@
package node package node
import ( import (
"bytes"
"context" "context"
"database/sql" "database/sql"
"errors" "errors"
"fmt"
"mediarr/cluster"
"mediarr/database" "mediarr/database"
"mediarr/ident" "mediarr/ident"
"time" "time"
@@ -29,8 +32,64 @@ func (n *Node) Up() error {
} }
} }
return n.ensureClusterIdentity(ctx)
}
func (n *Node) ensureClusterIdentity(ctx context.Context) error {
principal, err := n.db.Queries.GetClusterPrincipal(ctx)
switch {
case err == nil:
identity, 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) {
return errors.New("cluster : la clé publique de cluster.key ne correspond pas au principal en base")
}
n.cluster = identity
return nil return nil
case errors.Is(err, sql.ErrNoRows):
identity, createErr := cluster.LoadOrCreate(n.clusterKeyPath, true)
if createErr != nil {
return createErr
}
clusterID, idErr := ident.NewV7()
if idErr != nil {
return idErr
}
_, createErr = n.db.WriteQueries.CreatePrincipal(ctx, database.CreatePrincipalParams{
ID: clusterID,
Kind: "cluster",
Name: "cluster",
PublicKey: identity.PublicKeyBytes(),
Status: "active",
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
return nil
}
return fmt.Errorf("cluster : création du principal : %w", createErr)
}
n.cluster = identity
return nil
default:
return fmt.Errorf("cluster : lecture du principal : %w", err)
}
} }
func requiredNodePrincipals(now int64) []database.CreatePrincipalParams { func requiredNodePrincipals(now int64) []database.CreatePrincipalParams {
+162
View File
@@ -0,0 +1,162 @@
package node
import (
"bytes"
"context"
"os"
"path/filepath"
"testing"
"mediarr/cluster"
)
func TestUpCreatesAndKeepsClusterIdentity(t *testing.T) {
t.Chdir(t.TempDir())
keyPath := filepath.Join(t.TempDir(), "cluster.key")
err, node := NewNode(NewNodeParams{DatabaseName: "identity", ClusterKeyPath: keyPath})
if err != nil {
t.Fatalf("NewNode : %v", err)
}
t.Cleanup(func() { _ = node.Close() })
if err := node.Up(); err != nil {
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))
}
principal, err := node.db.Queries.GetClusterPrincipal(context.Background())
if err != nil {
t.Fatalf("GetClusterPrincipal : %v", err)
}
if principal.Kind != "cluster" {
t.Fatalf("kind = %q, attendu cluster", principal.Kind)
}
if principal.Name != "cluster" {
t.Fatalf("name = %q, attendu cluster", principal.Name)
}
if principal.Status != "active" {
t.Fatalf("status = %q, attendu active", principal.Status)
}
if !bytes.Equal(principal.PublicKey, identity.PublicKey) {
t.Fatal("la clé publique en base ne correspond pas à la clé chargée")
}
if err := node.Up(); err != nil {
t.Fatalf("second Up : %v", err)
}
again, err := node.db.Queries.GetClusterPrincipal(context.Background())
if err != nil {
t.Fatalf("GetClusterPrincipal après second Up : %v", err)
}
if again.ID != principal.ID {
t.Fatal("le principal cluster a été recréé au lieu d'être réutilisé")
}
}
func TestUpReusesKeyWhenDatabaseRecreated(t *testing.T) {
t.Chdir(t.TempDir())
keyPath := filepath.Join(t.TempDir(), "cluster.key")
err, first := NewNode(NewNodeParams{DatabaseName: "recreate", ClusterKeyPath: keyPath})
if err != nil {
t.Fatalf("NewNode : %v", err)
}
if err := first.Up(); err != nil {
t.Fatalf("Up : %v", err)
}
firstPublicKey := first.ClusterIdentity().PublicKeyBytes()
if err := first.Close(); err != nil {
t.Fatalf("Close : %v", err)
}
removeDatabaseFiles(t, "recreate")
err, second := NewNode(NewNodeParams{DatabaseName: "recreate", ClusterKeyPath: keyPath})
if err != nil {
t.Fatalf("NewNode après recréation : %v", err)
}
t.Cleanup(func() { _ = second.Close() })
if err := second.Up(); err != nil {
t.Fatalf("Up après recréation : %v", err)
}
if !bytes.Equal(second.ClusterIdentity().PublicKeyBytes(), firstPublicKey) {
t.Fatal("la clé du cluster a changé après recréation de la base")
}
}
func TestUpFailsWhenKeyMissing(t *testing.T) {
t.Chdir(t.TempDir())
keyPath := filepath.Join(t.TempDir(), "cluster.key")
err, node := NewNode(NewNodeParams{DatabaseName: "missingkey", ClusterKeyPath: keyPath})
if err != nil {
t.Fatalf("NewNode : %v", err)
}
t.Cleanup(func() { _ = node.Close() })
if err := node.Up(); err != nil {
t.Fatalf("Up : %v", err)
}
if err := os.Remove(keyPath); err != nil {
t.Fatal(err)
}
if err := node.Up(); err == nil {
t.Fatal("Up aurait dû échouer sans la clé du cluster")
}
}
func TestUpFailsOnKeyMismatch(t *testing.T) {
t.Chdir(t.TempDir())
keyPath := filepath.Join(t.TempDir(), "cluster.key")
err, node := NewNode(NewNodeParams{DatabaseName: "mismatch", ClusterKeyPath: keyPath})
if err != nil {
t.Fatalf("NewNode : %v", err)
}
t.Cleanup(func() { _ = node.Close() })
if err := node.Up(); err != nil {
t.Fatalf("Up : %v", err)
}
if err := os.Remove(keyPath); err != nil {
t.Fatal(err)
}
if _, err := cluster.LoadOrCreate(keyPath, true); err != nil {
t.Fatalf("génération d'une nouvelle clé : %v", err)
}
if err := node.Up(); err == nil {
t.Fatal("Up aurait dû détecter un mismatch entre la clé et le principal")
}
}
func removeDatabaseFiles(t *testing.T, databaseName string) {
t.Helper()
for _, suffix := range []string{"", "-wal", "-shm"} {
path := databaseName + ".db" + suffix
if err := os.Remove(path); err != nil && !os.IsNotExist(err) {
t.Fatalf("suppression de %s : %v", path, err)
}
}
}