// Package backup is de BlueGit-kant van bluegit-backup: de Backupserver-Key, // de koppeling met één backup server, het manifest van alle gegevens, het // ondertekenen van verzoeken en het terugzetten van een backup bij de start. // // De koppeling staat in /backup.json en het instance-id in // /instance_id. Die twee bestanden horen bij deze installatie en gaan // niet mee in een backup, zodat een rollback de koppeling niet terugdraait. package backup import ( "crypto/rand" "crypto/sha256" "crypto/subtle" "encoding/hex" "encoding/json" "errors" "os" "path/filepath" "strings" "sync" "time" ) // KeyPrefix staat voor elke Backupserver-Key. const KeyPrefix = "bgbk_" const ( connFile = "backup.json" instanceFile = "instance_id" ) // Conn is de opgeslagen koppeling. De key zelf wordt nooit bewaard. type Conn struct { KeyHash string `json:"key_hash"` SignSecret string `json:"sign_secret"` KeyHint string `json:"key_hint"` CreatedAt time.Time `json:"created_at"` CreatedBy string `json:"created_by"` ServerURL string `json:"server_url,omitempty"` ServerID string `json:"server_id,omitempty"` ConnectedAt time.Time `json:"connected_at,omitempty"` LastSeen time.Time `json:"last_seen,omitempty"` } // HasKey zegt of er een key is uitgegeven. func (c Conn) HasKey() bool { return c.KeyHash != "" } // Connected zegt of een backup server zich met de key heeft gemeld. func (c Conn) Connected() bool { return c.HasKey() && c.ServerURL != "" } // Manager bewaart de koppeling in de state-map. type Manager struct { Dir string mu sync.Mutex } // HashKey is de opgeslagen vorm van de key. func HashKey(key string) string { s := sha256.Sum256([]byte(key)) return hex.EncodeToString(s[:]) } // SigningSecret leidt het HMAC-geheim af uit de key. De backup server doet // precies hetzelfde, zodat beide kanten verzoeken kunnen ondertekenen. func SigningSecret(key string) string { s := sha256.Sum256([]byte("bluegit-backup-sign:" + key)) return hex.EncodeToString(s[:]) } // Load leest de koppeling. Geen bestand is een lege koppeling. func (m *Manager) Load() (Conn, error) { m.mu.Lock() defer m.mu.Unlock() return m.load() } func (m *Manager) load() (Conn, error) { var c Conn b, err := os.ReadFile(filepath.Join(m.Dir, connFile)) if errors.Is(err, os.ErrNotExist) { return c, nil } if err != nil { return c, err } err = json.Unmarshal(b, &c) return c, err } func (m *Manager) save(c Conn) error { if m.Dir == "" { return errors.New("geen state-map") } b, err := json.MarshalIndent(c, "", " ") if err != nil { return err } tmp := filepath.Join(m.Dir, connFile+".tmp") if err := os.WriteFile(tmp, b, 0o600); err != nil { return err } return os.Rename(tmp, filepath.Join(m.Dir, connFile)) } // NewKey maakt een nieuwe key en vervangt de oude. Een gekoppelde backup // server verliest daarmee zijn toegang tot hij de nieuwe key krijgt. func (m *Manager) NewKey(by string) (string, Conn, error) { raw := make([]byte, 32) if _, err := rand.Read(raw); err != nil { return "", Conn{}, err } key := KeyPrefix + hex.EncodeToString(raw) c := Conn{ KeyHash: HashKey(key), SignSecret: SigningSecret(key), KeyHint: key[:len(KeyPrefix)+6], CreatedAt: time.Now().UTC(), CreatedBy: by, } m.mu.Lock() defer m.mu.Unlock() if err := m.save(c); err != nil { return "", Conn{}, err } return key, c, nil } // Revoke trekt de key in en vergeet de backup server. func (m *Manager) Revoke() error { m.mu.Lock() defer m.mu.Unlock() err := os.Remove(filepath.Join(m.Dir, connFile)) if errors.Is(err, os.ErrNotExist) { return nil } return err } // Check zegt of key de uitgegeven key is. func (m *Manager) Check(key string) (Conn, bool) { key = strings.TrimSpace(key) if !strings.HasPrefix(key, KeyPrefix) { return Conn{}, false } c, err := m.Load() if err != nil || !c.HasKey() { return Conn{}, false } if subtle.ConstantTimeCompare([]byte(HashKey(key)), []byte(c.KeyHash)) != 1 { return Conn{}, false } return c, true } // Connect legt het adres van de backup server vast. func (m *Manager) Connect(serverURL, serverID string) (Conn, error) { m.mu.Lock() defer m.mu.Unlock() c, err := m.load() if err != nil { return c, err } if !c.HasKey() { return c, errors.New("geen key") } c.ServerURL = strings.TrimRight(strings.TrimSpace(serverURL), "/") c.ServerID = serverID c.ConnectedAt = time.Now().UTC() c.LastSeen = c.ConnectedAt return c, m.save(c) } // Seen werkt LastSeen bij, hoogstens één keer per minuut naar schijf. func (m *Manager) Seen() { m.mu.Lock() defer m.mu.Unlock() c, err := m.load() if err != nil || !c.HasKey() || time.Since(c.LastSeen) < time.Minute { return } c.LastSeen = time.Now().UTC() _ = m.save(c) } // InstanceID is het vaste id van deze installatie. Het wordt één keer // gemaakt en gaat niet mee in een backup. func (m *Manager) InstanceID() (string, error) { m.mu.Lock() defer m.mu.Unlock() p := filepath.Join(m.Dir, instanceFile) if b, err := os.ReadFile(p); err == nil { if id := strings.TrimSpace(string(b)); id != "" { return id, nil } } raw := make([]byte, 16) if _, err := rand.Read(raw); err != nil { return "", err } id := hex.EncodeToString(raw) if err := os.MkdirAll(m.Dir, 0o750); err != nil { return "", err } return id, os.WriteFile(p, []byte(id+"\n"), 0o600) }