BlueGit

timfa bluegit

Files

bluegit / internal / backup / conn.go

conn.go

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