BlueGit

timfa bluegit

Files

bluegit / internal / backup / conn.go

conn.go

conn.go 9.2 KiB Download Raw
1// Package backup is de BlueGit-kant van bluegit-backup: de Backupserver-Keys,
2// de koppelingen met een of meer backup servers, het manifest van alle gegevens, het
3// ondertekenen van verzoeken en het terugzetten van een backup bij de start.
4//
5// De koppeling staat in <state>/backup.json en het instance-id in
6// <state>/instance_id. Die twee bestanden horen bij deze installatie en gaan
7// niet mee in een backup, zodat een rollback de koppeling niet terugdraait.
8package backup
9
10import (
11 "crypto/rand"
12 "crypto/sha256"
13 "crypto/subtle"
14 "encoding/hex"
15 "encoding/json"
16 "errors"
17 "os"
18 "path/filepath"
19 "strings"
20 "sync"
21 "time"
22)
23
24// KeyPrefix staat voor elke Backupserver-Key.
25const KeyPrefix = "bgbk_"
26
27const (
28 connFile = "backup.json"
29 instanceFile = "instance_id"
30)
31
32// Conn is één backup server. De key zelf wordt nooit bewaard.
33type Conn struct {
34 ID string `json:"id"`
35 Name string `json:"name"`
36 KeyHash string `json:"key_hash"`
37 SignSecret string `json:"sign_secret"`
38 KeyHint string `json:"key_hint"`
39 CreatedAt time.Time `json:"created_at"`
40 CreatedBy string `json:"created_by"`
41 ServerURL string `json:"server_url,omitempty"`
42 ServerID string `json:"server_id,omitempty"`
43 ConnectedAt time.Time `json:"connected_at,omitempty"`
44 LastSeen time.Time `json:"last_seen,omitempty"`
45 // Protocol van de backup server zoals hij het laatst meldde (0: nog
46 // onbekend). Zie compat.go.
47 PeerProtocol int `json:"peer_protocol,omitempty"`
48 PeerMinProtocol int `json:"peer_min_protocol,omitempty"`
49 PeerVersion string `json:"peer_version,omitempty"`
50 // Sync is de laatst gemelde voortgang van deze backup server.
51 Sync Progress `json:"sync,omitempty"`
52}
53
54// HasKey zegt of er een key is uitgegeven.
55func (c Conn) HasKey() bool { return c.KeyHash != "" }
56
57// Connected zegt of een backup server zich met de key heeft gemeld.
58func (c Conn) Connected() bool { return c.HasKey() && c.ServerURL != "" }
59
60// MaxServers begrenst het aantal backup servers per BlueGit.
61const MaxServers = 16
62
63// file is backup.json. Eén BlueGit kan meerdere backup servers hebben; een
64// backup server hoort bij één BlueGit.
65type file struct {
66 Servers []Conn `json:"servers"`
67}
68
69// Manager bewaart de koppelingen in de state-map.
70type Manager struct {
71 Dir string
72 mu sync.Mutex
73}
74
75// HashKey is de opgeslagen vorm van de key.
76func HashKey(key string) string {
77 s := sha256.Sum256([]byte(key))
78 return hex.EncodeToString(s[:])
79}
80
81// SigningSecret leidt het HMAC-geheim af uit de key. De backup server doet
82// precies hetzelfde, zodat beide kanten verzoeken kunnen ondertekenen.
83func SigningSecret(key string) string {
84 s := sha256.Sum256([]byte("bluegit-backup-sign:" + key))
85 return hex.EncodeToString(s[:])
86}
87
88// List geeft alle backup servers, in volgorde van aanmaken.
89func (m *Manager) List() ([]Conn, error) {
90 m.mu.Lock()
91 defer m.mu.Unlock()
92 f, err := m.load()
93 return f.Servers, err
94}
95
96// Get zoekt een backup server op id.
97func (m *Manager) Get(id string) (Conn, bool) {
98 list, err := m.List()
99 if err != nil {
100 return Conn{}, false
101 }
102 for _, c := range list {
103 if c.ID == id {
104 return c, true
105 }
106 }
107 return Conn{}, false
108}
109
110func (m *Manager) load() (file, error) {
111 var f file
112 b, err := os.ReadFile(filepath.Join(m.Dir, connFile))
113 if errors.Is(err, os.ErrNotExist) {
114 return f, nil
115 }
116 if err != nil {
117 return f, err
118 }
119 if err := json.Unmarshal(b, &f); err != nil {
120 return f, err
121 }
122 if f.Servers == nil {
123 // Oude vorm met één koppeling.
124 var one Conn
125 if json.Unmarshal(b, &one) == nil && one.HasKey() {
126 if one.ID == "" {
127 one.ID = newID()
128 }
129 if one.Name == "" {
130 one.Name = "backup"
131 }
132 f.Servers = []Conn{one}
133 // Meteen bewaren, zodat het id vast is.
134 if err := m.save(f); err != nil {
135 return f, err
136 }
137 }
138 }
139 return f, nil
140}
141
142func (m *Manager) save(f file) error {
143 if m.Dir == "" {
144 return errors.New("geen state-map")
145 }
146 if f.Servers == nil {
147 f.Servers = []Conn{}
148 }
149 b, err := json.MarshalIndent(f, "", " ")
150 if err != nil {
151 return err
152 }
153 tmp := filepath.Join(m.Dir, connFile+".tmp")
154 if err := os.WriteFile(tmp, b, 0o600); err != nil {
155 return err
156 }
157 return os.Rename(tmp, filepath.Join(m.Dir, connFile))
158}
159
160func (m *Manager) update(id string, fn func(*Conn) error) (Conn, error) {
161 m.mu.Lock()
162 defer m.mu.Unlock()
163 f, err := m.load()
164 if err != nil {
165 return Conn{}, err
166 }
167 for i := range f.Servers {
168 if f.Servers[i].ID == id {
169 if err := fn(&f.Servers[i]); err != nil {
170 return Conn{}, err
171 }
172 return f.Servers[i], m.save(f)
173 }
174 }
175 return Conn{}, ErrUnknown
176}
177
178// ErrUnknown: geen backup server met dat id.
179var ErrUnknown = errors.New("onbekende backup server")
180
181func newID() string {
182 raw := make([]byte, 6)
183 _, _ = rand.Read(raw)
184 return hex.EncodeToString(raw)
185}
186
187func newKey() (string, error) {
188 raw := make([]byte, 32)
189 if _, err := rand.Read(raw); err != nil {
190 return "", err
191 }
192 return KeyPrefix + hex.EncodeToString(raw), nil
193}
194
195// CleanName maakt van een naam iets korts en toonbaars.
196func CleanName(name string) string {
197 name = strings.Join(strings.Fields(name), " ")
198 if r := []rune(name); len(r) > 60 {
199 name = string(r[:60])
200 }
201 return name
202}
203
204// Add maakt een nieuwe backup server met een eigen key. De key wordt
205// alleen hier teruggegeven.
206func (m *Manager) Add(name, by string) (string, Conn, error) {
207 name = CleanName(name)
208 if name == "" {
209 name = "backup"
210 }
211 key, err := newKey()
212 if err != nil {
213 return "", Conn{}, err
214 }
215 c := Conn{
216 ID: newID(), Name: name, KeyHash: HashKey(key), SignSecret: SigningSecret(key),
217 KeyHint: key[:len(KeyPrefix)+6], CreatedAt: time.Now().UTC(), CreatedBy: by,
218 }
219 m.mu.Lock()
220 defer m.mu.Unlock()
221 f, err := m.load()
222 if err != nil {
223 return "", Conn{}, err
224 }
225 if len(f.Servers) >= MaxServers {
226 return "", Conn{}, ErrTooMany
227 }
228 f.Servers = append(f.Servers, c)
229 if err := m.save(f); err != nil {
230 return "", Conn{}, err
231 }
232 return key, c, nil
233}
234
235// ErrTooMany: MaxServers bereikt.
236var ErrTooMany = errors.New("te veel backup servers")
237
238// RotateKey geeft een backup server een nieuwe key. Hij verliest zijn
239// toegang tot hij opnieuw koppelt met de nieuwe key.
240func (m *Manager) RotateKey(id, by string) (string, Conn, error) {
241 key, err := newKey()
242 if err != nil {
243 return "", Conn{}, err
244 }
245 c, err := m.update(id, func(c *Conn) error {
246 c.KeyHash, c.SignSecret, c.KeyHint = HashKey(key), SigningSecret(key), key[:len(KeyPrefix)+6]
247 c.CreatedAt, c.CreatedBy = time.Now().UTC(), by
248 c.ServerURL, c.ServerID, c.ConnectedAt = "", "", time.Time{}
249 c.PeerProtocol, c.PeerMinProtocol, c.PeerVersion = 0, 0, ""
250 return nil
251 })
252 if err != nil {
253 return "", Conn{}, err
254 }
255 return key, c, nil
256}
257
258// Rename geeft een backup server een andere naam.
259func (m *Manager) Rename(id, name string) (Conn, error) {
260 name = CleanName(name)
261 if name == "" {
262 return Conn{}, errors.New("naam is leeg")
263 }
264 return m.update(id, func(c *Conn) error { c.Name = name; return nil })
265}
266
267// Remove trekt de key in en vergeet de backup server.
268func (m *Manager) Remove(id string) error {
269 m.mu.Lock()
270 defer m.mu.Unlock()
271 f, err := m.load()
272 if err != nil {
273 return err
274 }
275 out := f.Servers[:0]
276 found := false
277 for _, c := range f.Servers {
278 if c.ID == id {
279 found = true
280 continue
281 }
282 out = append(out, c)
283 }
284 if !found {
285 return ErrUnknown
286 }
287 f.Servers = out
288 return m.save(f)
289}
290
291// Check zoekt de backup server bij key.
292func (m *Manager) Check(key string) (Conn, bool) {
293 key = strings.TrimSpace(key)
294 if !strings.HasPrefix(key, KeyPrefix) {
295 return Conn{}, false
296 }
297 list, err := m.List()
298 if err != nil {
299 return Conn{}, false
300 }
301 h := HashKey(key)
302 for _, c := range list {
303 if c.HasKey() && subtle.ConstantTimeCompare([]byte(h), []byte(c.KeyHash)) == 1 {
304 return c, true
305 }
306 }
307 return Conn{}, false
308}
309
310// Connect legt het adres van een backup server vast.
311func (m *Manager) Connect(id, serverURL, serverID string) (Conn, error) {
312 return m.update(id, func(c *Conn) error {
313 c.ServerURL = strings.TrimRight(strings.TrimSpace(serverURL), "/")
314 c.ServerID = serverID
315 c.ConnectedAt = time.Now().UTC()
316 c.LastSeen = c.ConnectedAt
317 return nil
318 })
319}
320
321// Seen werkt LastSeen bij, hoogstens één keer per minuut naar schijf.
322func (m *Manager) Seen(id string) {
323 c, ok := m.Get(id)
324 if !ok || time.Since(c.LastSeen) < time.Minute {
325 return
326 }
327 _, _ = m.update(id, func(c *Conn) error { c.LastSeen = time.Now().UTC(); return nil })
328}
329
330// InstanceID is het vaste id van deze installatie. Het wordt één keer
331// gemaakt en gaat niet mee in een backup.
332func (m *Manager) InstanceID() (string, error) {
333 m.mu.Lock()
334 defer m.mu.Unlock()
335 p := filepath.Join(m.Dir, instanceFile)
336 if b, err := os.ReadFile(p); err == nil {
337 if id := strings.TrimSpace(string(b)); id != "" {
338 return id, nil
339 }
340 }
341 raw := make([]byte, 16)
342 if _, err := rand.Read(raw); err != nil {
343 return "", err
344 }
345 id := hex.EncodeToString(raw)
346 if err := os.MkdirAll(m.Dir, 0o750); err != nil {
347 return "", err
348 }
349 return id, os.WriteFile(p, []byte(id+"\n"), 0o600)
350}
351
352// SetSyncProgress bewaart de laatst gemelde sync-voortgang van een backup server.
353func (m *Manager) SetSyncProgress(id string, p Progress) error {
354 _, err := m.update(id, func(c *Conn) error {
355 c.Sync = p
356 if !c.LastSeen.IsZero() || p.Known {
357 c.LastSeen = time.Now().UTC()
358 }
359 return nil
360 })
361 return err
362}