// Package backup is de BlueGit-kant van bluegit-backup: de Backupserver-Keys, // de koppelingen met een of meer backup servers, 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 één backup server. De key zelf wordt nooit bewaard. type Conn struct { ID string `json:"id"` Name string `json:"name"` 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 != "" } // MaxServers begrenst het aantal backup servers per BlueGit. const MaxServers = 16 // file is backup.json. Eén BlueGit kan meerdere backup servers hebben; een // backup server hoort bij één BlueGit. type file struct { Servers []Conn `json:"servers"` } // Manager bewaart de koppelingen 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[:]) } // List geeft alle backup servers, in volgorde van aanmaken. func (m *Manager) List() ([]Conn, error) { m.mu.Lock() defer m.mu.Unlock() f, err := m.load() return f.Servers, err } // Get zoekt een backup server op id. func (m *Manager) Get(id string) (Conn, bool) { list, err := m.List() if err != nil { return Conn{}, false } for _, c := range list { if c.ID == id { return c, true } } return Conn{}, false } func (m *Manager) load() (file, error) { var f file b, err := os.ReadFile(filepath.Join(m.Dir, connFile)) if errors.Is(err, os.ErrNotExist) { return f, nil } if err != nil { return f, err } if err := json.Unmarshal(b, &f); err != nil { return f, err } if f.Servers == nil { // Oude vorm met één koppeling. var one Conn if json.Unmarshal(b, &one) == nil && one.HasKey() { if one.ID == "" { one.ID = newID() } if one.Name == "" { one.Name = "backup" } f.Servers = []Conn{one} // Meteen bewaren, zodat het id vast is. if err := m.save(f); err != nil { return f, err } } } return f, nil } func (m *Manager) save(f file) error { if m.Dir == "" { return errors.New("geen state-map") } if f.Servers == nil { f.Servers = []Conn{} } b, err := json.MarshalIndent(f, "", " ") 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)) } func (m *Manager) update(id string, fn func(*Conn) error) (Conn, error) { m.mu.Lock() defer m.mu.Unlock() f, err := m.load() if err != nil { return Conn{}, err } for i := range f.Servers { if f.Servers[i].ID == id { if err := fn(&f.Servers[i]); err != nil { return Conn{}, err } return f.Servers[i], m.save(f) } } return Conn{}, ErrUnknown } // ErrUnknown: geen backup server met dat id. var ErrUnknown = errors.New("onbekende backup server") func newID() string { raw := make([]byte, 6) _, _ = rand.Read(raw) return hex.EncodeToString(raw) } func newKey() (string, error) { raw := make([]byte, 32) if _, err := rand.Read(raw); err != nil { return "", err } return KeyPrefix + hex.EncodeToString(raw), nil } // CleanName maakt van een naam iets korts en toonbaars. func CleanName(name string) string { name = strings.Join(strings.Fields(name), " ") if r := []rune(name); len(r) > 60 { name = string(r[:60]) } return name } // Add maakt een nieuwe backup server met een eigen key. De key wordt // alleen hier teruggegeven. func (m *Manager) Add(name, by string) (string, Conn, error) { name = CleanName(name) if name == "" { name = "backup" } key, err := newKey() if err != nil { return "", Conn{}, err } c := Conn{ ID: newID(), Name: name, KeyHash: HashKey(key), SignSecret: SigningSecret(key), KeyHint: key[:len(KeyPrefix)+6], CreatedAt: time.Now().UTC(), CreatedBy: by, } m.mu.Lock() defer m.mu.Unlock() f, err := m.load() if err != nil { return "", Conn{}, err } if len(f.Servers) >= MaxServers { return "", Conn{}, ErrTooMany } f.Servers = append(f.Servers, c) if err := m.save(f); err != nil { return "", Conn{}, err } return key, c, nil } // ErrTooMany: MaxServers bereikt. var ErrTooMany = errors.New("te veel backup servers") // RotateKey geeft een backup server een nieuwe key. Hij verliest zijn // toegang tot hij opnieuw koppelt met de nieuwe key. func (m *Manager) RotateKey(id, by string) (string, Conn, error) { key, err := newKey() if err != nil { return "", Conn{}, err } c, err := m.update(id, func(c *Conn) error { c.KeyHash, c.SignSecret, c.KeyHint = HashKey(key), SigningSecret(key), key[:len(KeyPrefix)+6] c.CreatedAt, c.CreatedBy = time.Now().UTC(), by c.ServerURL, c.ServerID, c.ConnectedAt = "", "", time.Time{} return nil }) if err != nil { return "", Conn{}, err } return key, c, nil } // Rename geeft een backup server een andere naam. func (m *Manager) Rename(id, name string) (Conn, error) { name = CleanName(name) if name == "" { return Conn{}, errors.New("naam is leeg") } return m.update(id, func(c *Conn) error { c.Name = name; return nil }) } // Remove trekt de key in en vergeet de backup server. func (m *Manager) Remove(id string) error { m.mu.Lock() defer m.mu.Unlock() f, err := m.load() if err != nil { return err } out := f.Servers[:0] found := false for _, c := range f.Servers { if c.ID == id { found = true continue } out = append(out, c) } if !found { return ErrUnknown } f.Servers = out return m.save(f) } // Check zoekt de backup server bij key. func (m *Manager) Check(key string) (Conn, bool) { key = strings.TrimSpace(key) if !strings.HasPrefix(key, KeyPrefix) { return Conn{}, false } list, err := m.List() if err != nil { return Conn{}, false } h := HashKey(key) for _, c := range list { if c.HasKey() && subtle.ConstantTimeCompare([]byte(h), []byte(c.KeyHash)) == 1 { return c, true } } return Conn{}, false } // Connect legt het adres van een backup server vast. func (m *Manager) Connect(id, serverURL, serverID string) (Conn, error) { return m.update(id, func(c *Conn) error { c.ServerURL = strings.TrimRight(strings.TrimSpace(serverURL), "/") c.ServerID = serverID c.ConnectedAt = time.Now().UTC() c.LastSeen = c.ConnectedAt return nil }) } // Seen werkt LastSeen bij, hoogstens één keer per minuut naar schijf. func (m *Manager) Seen(id string) { c, ok := m.Get(id) if !ok || time.Since(c.LastSeen) < time.Minute { return } _, _ = m.update(id, func(c *Conn) error { c.LastSeen = time.Now().UTC(); return nil }) } // 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) }