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...) }