mirror of
https://github.com/R0m1k3/Loki.git
synced 2026-10-11 17:26:57 +02:00
Claude
fa69dac77f
Reprise d'AJEAN (mem_crypto/mem_vault/mem_store/mem_io/mem_migrate/ mem_snapshots/mem_health/mem_fsutil + backup_bundle), adaptée à Loki. Chiffrement à enveloppe : une DEK tirée une fois chiffre les données en AES-256-GCM ; elle est enfermée dans un coffre par une KEK dérivée en Argon2id. Ce qui ouvre le coffre : la clé de pilotage de l'appareil (le serveur n'en a que l'empreinte, il ne peut pas ouvrir seul) ou la clé de récupération donnée une fois. La DEK ne vit qu'en RAM. Périmètre chiffré, choisi pour Loki : les pages mémoire, les discussions (journal ET index, qui porte les titres), les blocs archivés au compactage — du verbatim de conversation — et les trackers. Pas les buckets de réglages : le coffre lui-même y vit, les chiffrer serait une boucle. Verrouillé, rien n'est écrasé : putStoreBytes REFUSE d'écrire du clair par-dessus du chiffré, la liste des discussions se lit vide et les pages s'affichent « 🔒 chiffré ». Le déverrouillage recharge la discussion et rattrape ce qui serait resté en clair. Une migration interrompue reprend au démarrage, un snapshot est pris avant chaque bascule, et aucune donnée n'est supprimée avant relecture vérifiée de son remplaçant. Piège corrigé au passage : chiffrer À L'INTÉRIEUR d'une transaction bbolt se bloquait sur le verrou de la base (memEncActive relit la config, donc la base). L'état du chiffrement est désormais résolu AVANT la transaction (memEncoderNow), qui ne reçoit plus qu'un encodeur pur. Sauvegarde : le paquet chiffré {mémoire, presets, réglages} s'exporte et s'importe en FICHIER (/api/backup/export, /api/backup/import). La sauvegarde vers le relais ajean.link n'est pas reprise — c'est le service de l'auteur amont ; ici le fichier reste chez soi. Le dossier mémoire n'était déjà plus joignable qu'aux outils mem_* : c'était la condition de ce chiffrement (un `cat memory/…` aurait rendu du binaire). Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01K6CAgoLJzufeA8rZTSpSpY
77 lines
2.1 KiB
Go
77 lines
2.1 KiB
Go
package loki
|
|
|
|
// mem_fsutil.go — écritures fichier sûres pour la mémoire : temporaire + fsync +
|
|
// rename atomique. Aucune donnée n'est jamais écrite « en place » par-dessus une
|
|
// ancienne : on écrit à côté, on force sur disque, puis on bascule d'un rename
|
|
// (atomique au niveau du système de fichiers).
|
|
|
|
import (
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
)
|
|
|
|
// memWriteFileAtomic écrit data dans path de façon atomique et durable. En cas
|
|
// d'échec, path conserve son ancien contenu (le temporaire est nettoyé).
|
|
func memWriteFileAtomic(path string, data []byte, perm os.FileMode) error {
|
|
dir := filepath.Dir(path)
|
|
if err := os.MkdirAll(dir, 0o755); err != nil {
|
|
return err
|
|
}
|
|
tmp, err := os.CreateTemp(dir, ".tmp-"+filepath.Base(path)+"-*")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
tmpName := tmp.Name()
|
|
cleanup := func() {
|
|
tmp.Close()
|
|
os.Remove(tmpName)
|
|
}
|
|
if _, err := tmp.Write(data); err != nil {
|
|
cleanup()
|
|
return err
|
|
}
|
|
if err := tmp.Sync(); err != nil { // durabilité : sur disque avant rename
|
|
cleanup()
|
|
return err
|
|
}
|
|
if err := tmp.Close(); err != nil {
|
|
os.Remove(tmpName)
|
|
return err
|
|
}
|
|
if err := os.Chmod(tmpName, perm); err != nil {
|
|
os.Remove(tmpName)
|
|
return err
|
|
}
|
|
if err := os.Rename(tmpName, path); err != nil {
|
|
os.Remove(tmpName)
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// memWriteFileVerified écrit data atomiquement PUIS relit le fichier et compare
|
|
// octet pour octet. C'est la garantie « ce qui est sur le disque est bien ce
|
|
// qu'on voulait » avant toute suppression de l'original. En cas d'écart, le
|
|
// fichier écrit est retiré et une erreur est renvoyée.
|
|
func memWriteFileVerified(path string, data []byte, perm os.FileMode) error {
|
|
if err := memWriteFileAtomic(path, data, perm); err != nil {
|
|
return err
|
|
}
|
|
back, err := os.ReadFile(path)
|
|
if err != nil {
|
|
return fmt.Errorf("relecture de vérification impossible : %w", err)
|
|
}
|
|
if len(back) != len(data) {
|
|
os.Remove(path)
|
|
return fmt.Errorf("vérification échouée : %d octets relus, %d écrits", len(back), len(data))
|
|
}
|
|
for i := range back {
|
|
if back[i] != data[i] {
|
|
os.Remove(path)
|
|
return fmt.Errorf("vérification échouée : octet %d diffère", i)
|
|
}
|
|
}
|
|
return nil
|
|
}
|