BlueGit

timfa bluegit

Files

bluegit / internal / backup / conn.go

conn.go

conn.go 5.3 KiB Download Raw
1// Package backup is de BlueGit-kant van bluegit-backup: de Backupserver-Key,
2// de koppeling met één backup server, 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 de opgeslagen koppeling. De key zelf wordt nooit bewaard.
33type Conn struct {
34 KeyHash string `json:"key_hash"`
35 SignSecret string `json:"sign_secret"`
36 KeyHint string `json:"key_hint"`
37 CreatedAt time.Time `json:"created_at"`
38 CreatedBy string `json:"created_by"`
39 ServerURL string `json:"server_url,omitempty"`
40 ServerID string `json:"server_id,omitempty"`
41 ConnectedAt time.Time `json:"connected_at,omitempty"`
42 LastSeen time.Time `json:"last_seen,omitempty"`
43}
44
45// HasKey zegt of er een key is uitgegeven.
46func (c Conn) HasKey() bool { return c.KeyHash != "" }
47
48// Connected zegt of een backup server zich met de key heeft gemeld.
49func (c Conn) Connected() bool { return c.HasKey() && c.ServerURL != "" }
50
51// Manager bewaart de koppeling in de state-map.
52type Manager struct {
53 Dir string
54 mu sync.Mutex
55}
56
57// HashKey is de opgeslagen vorm van de key.
58func HashKey(key string) string {
59 s := sha256.Sum256([]byte(key))
60 return hex.EncodeToString(s[:])
61}
62
63// SigningSecret leidt het HMAC-geheim af uit de key. De backup server doet
64// precies hetzelfde, zodat beide kanten verzoeken kunnen ondertekenen.
65func SigningSecret(key string) string {
66 s := sha256.Sum256([]byte("bluegit-backup-sign:" + key))
67 return hex.EncodeToString(s[:])
68}
69
70// Load leest de koppeling. Geen bestand is een lege koppeling.
71func (m *Manager) Load() (Conn, error) {
72 m.mu.Lock()
73 defer m.mu.Unlock()
74 return m.load()
75}
76
77func (m *Manager) load() (Conn, error) {
78 var c Conn
79 b, err := os.ReadFile(filepath.Join(m.Dir, connFile))
80 if errors.Is(err, os.ErrNotExist) {
81 return c, nil
82 }
83 if err != nil {
84 return c, err
85 }
86 err = json.Unmarshal(b, &c)
87 return c, err
88}
89
90func (m *Manager) save(c Conn) error {
91 if m.Dir == "" {
92 return errors.New("geen state-map")
93 }
94 b, err := json.MarshalIndent(c, "", " ")
95 if err != nil {
96 return err
97 }
98 tmp := filepath.Join(m.Dir, connFile+".tmp")
99 if err := os.WriteFile(tmp, b, 0o600); err != nil {
100 return err
101 }
102 return os.Rename(tmp, filepath.Join(m.Dir, connFile))
103}
104
105// NewKey maakt een nieuwe key en vervangt de oude. Een gekoppelde backup
106// server verliest daarmee zijn toegang tot hij de nieuwe key krijgt.
107func (m *Manager) NewKey(by string) (string, Conn, error) {
108 raw := make([]byte, 32)
109 if _, err := rand.Read(raw); err != nil {
110 return "", Conn{}, err
111 }
112 key := KeyPrefix + hex.EncodeToString(raw)
113 c := Conn{
114 KeyHash: HashKey(key), SignSecret: SigningSecret(key),
115 KeyHint: key[:len(KeyPrefix)+6], CreatedAt: time.Now().UTC(), CreatedBy: by,
116 }
117 m.mu.Lock()
118 defer m.mu.Unlock()
119 if err := m.save(c); err != nil {
120 return "", Conn{}, err
121 }
122 return key, c, nil
123}
124
125// Revoke trekt de key in en vergeet de backup server.
126func (m *Manager) Revoke() error {
127 m.mu.Lock()
128 defer m.mu.Unlock()
129 err := os.Remove(filepath.Join(m.Dir, connFile))
130 if errors.Is(err, os.ErrNotExist) {
131 return nil
132 }
133 return err
134}
135
136// Check zegt of key de uitgegeven key is.
137func (m *Manager) Check(key string) (Conn, bool) {
138 key = strings.TrimSpace(key)
139 if !strings.HasPrefix(key, KeyPrefix) {
140 return Conn{}, false
141 }
142 c, err := m.Load()
143 if err != nil || !c.HasKey() {
144 return Conn{}, false
145 }
146 if subtle.ConstantTimeCompare([]byte(HashKey(key)), []byte(c.KeyHash)) != 1 {
147 return Conn{}, false
148 }
149 return c, true
150}
151
152// Connect legt het adres van de backup server vast.
153func (m *Manager) Connect(serverURL, serverID string) (Conn, error) {
154 m.mu.Lock()
155 defer m.mu.Unlock()
156 c, err := m.load()
157 if err != nil {
158 return c, err
159 }
160 if !c.HasKey() {
161 return c, errors.New("geen key")
162 }
163 c.ServerURL = strings.TrimRight(strings.TrimSpace(serverURL), "/")
164 c.ServerID = serverID
165 c.ConnectedAt = time.Now().UTC()
166 c.LastSeen = c.ConnectedAt
167 return c, m.save(c)
168}
169
170// Seen werkt LastSeen bij, hoogstens één keer per minuut naar schijf.
171func (m *Manager) Seen() {
172 m.mu.Lock()
173 defer m.mu.Unlock()
174 c, err := m.load()
175 if err != nil || !c.HasKey() || time.Since(c.LastSeen) < time.Minute {
176 return
177 }
178 c.LastSeen = time.Now().UTC()
179 _ = m.save(c)
180}
181
182// InstanceID is het vaste id van deze installatie. Het wordt één keer
183// gemaakt en gaat niet mee in een backup.
184func (m *Manager) InstanceID() (string, error) {
185 m.mu.Lock()
186 defer m.mu.Unlock()
187 p := filepath.Join(m.Dir, instanceFile)
188 if b, err := os.ReadFile(p); err == nil {
189 if id := strings.TrimSpace(string(b)); id != "" {
190 return id, nil
191 }
192 }
193 raw := make([]byte, 16)
194 if _, err := rand.Read(raw); err != nil {
195 return "", err
196 }
197 id := hex.EncodeToString(raw)
198 if err := os.MkdirAll(m.Dir, 0o750); err != nil {
199 return "", err
200 }
201 return id, os.WriteFile(p, []byte(id+"\n"), 0o600)
202}