BlueGit

timfa bluegit

Files

bluegit / internal / backup / conn.go

conn.go

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