BlueGit

timfa bluegit

Files

bluegit / internal / backup / backup_test.go

backup_test.go

backup_test.go 11.6 KiB Download Raw
1package backup
2
3import (
4 "archive/tar"
5 "bytes"
6 "compress/gzip"
7 "crypto/sha256"
8 "encoding/hex"
9 "errors"
10 "fmt"
11 "net/http"
12 "os"
13 "path/filepath"
14 "strings"
15 "sync"
16 "testing"
17 "time"
18)
19
20func TestSignVerify(t *testing.T) {
21 sec := SigningSecret("bgbk_x")
22 now := time.Unix(1_800_000_000, 0)
23 body := []byte(`{"archive":"a"}`)
24 req, _ := http.NewRequest("POST", "http://b/api/v1/rollback", bytes.NewReader(body))
25 Sign(req, sec, "inst", body, now)
26 if err := Verify(req, sec, body, now.Add(time.Minute)); err != nil {
27 t.Fatal(err)
28 }
29 if Verify(req, sec, []byte(`{"archive":"b"}`), now) == nil {
30 t.Fatal("andere body geaccepteerd")
31 }
32 if Verify(req, SigningSecret("bgbk_y"), body, now) == nil {
33 t.Fatal("ander geheim geaccepteerd")
34 }
35 if Verify(req, sec, body, now.Add(10*time.Minute)) == nil {
36 t.Fatal("oude timestamp geaccepteerd")
37 }
38 req.URL.Path = "/api/v1/notify"
39 if Verify(req, sec, body, now) == nil {
40 t.Fatal("ander pad geaccepteerd")
41 }
42}
43
44func TestKeyLifecycle(t *testing.T) {
45 m := &Manager{Dir: t.TempDir()}
46 if _, ok := m.Check("bgbk_nope"); ok {
47 t.Fatal("check zonder key")
48 }
49 key, c, err := m.Add(" nas kelder ", "tim")
50 if err != nil || !strings.HasPrefix(key, KeyPrefix) || c.KeyHash == "" || c.Name != "nas kelder" || c.ID == "" {
51 t.Fatal(key, c, err)
52 }
53 raw, _ := os.ReadFile(filepath.Join(m.Dir, "backup.json"))
54 if strings.Contains(string(raw), key) {
55 t.Fatal("key staat leesbaar op schijf")
56 }
57 fi, _ := os.Stat(filepath.Join(m.Dir, "backup.json"))
58 if fi.Mode().Perm() != 0o600 {
59 t.Fatalf("mode %v", fi.Mode())
60 }
61 if got, ok := m.Check(key); !ok || got.ID != c.ID {
62 t.Fatal("eigen key geweigerd")
63 }
64 if _, err := m.Connect(c.ID, "http://backup:9000/", "srv1"); err != nil {
65 t.Fatal(err)
66 }
67 c, _ = m.Get(c.ID)
68 if !c.Connected() || c.ServerURL != "http://backup:9000" || c.SignSecret != SigningSecret(key) {
69 t.Fatalf("%+v", c)
70 }
71 // Een tweede backup server met een eigen key; de eerste blijft werken.
72 keyB, b, err := m.Add("offsite", "tim")
73 if err != nil {
74 t.Fatal(err)
75 }
76 if got, ok := m.Check(keyB); !ok || got.ID != b.ID {
77 t.Fatal("tweede key")
78 }
79 if got, ok := m.Check(key); !ok || got.ID != c.ID {
80 t.Fatal("eerste key werkt niet meer")
81 }
82 if list, _ := m.List(); len(list) != 2 {
83 t.Fatalf("%d servers", len(list))
84 }
85 // Nieuwe key voor de eerste: oude key dood, koppeling weg, tweede blijft.
86 key2, _, err := m.RotateKey(c.ID, "tim")
87 if err != nil {
88 t.Fatal(err)
89 }
90 if _, ok := m.Check(key); ok {
91 t.Fatal("oude key werkt nog")
92 }
93 if _, ok := m.Check(key2); !ok {
94 t.Fatal("nieuwe key geweigerd")
95 }
96 if c, _ := m.Get(c.ID); c.Connected() {
97 t.Fatal("nieuwe key houdt oude server vast")
98 }
99 if _, err := m.Rename(b.ID, "Offsite 2"); err != nil {
100 t.Fatal(err)
101 }
102 if b, _ := m.Get(b.ID); b.Name != "Offsite 2" {
103 t.Fatal(b.Name)
104 }
105 id1, _ := m.InstanceID()
106 id2, _ := m.InstanceID()
107 if id1 == "" || id1 != id2 {
108 t.Fatal("instance-id niet vast")
109 }
110 if err := m.Remove(c.ID); err != nil {
111 t.Fatal(err)
112 }
113 if _, ok := m.Check(key2); ok {
114 t.Fatal("ingetrokken key werkt")
115 }
116 if _, ok := m.Check(keyB); !ok {
117 t.Fatal("andere server verloor zijn key")
118 }
119 if err := m.Remove("bestaatniet"); err != ErrUnknown {
120 t.Fatal(err)
121 }
122 for i := 0; i < MaxServers; i++ {
123 _, _, _ = m.Add("x", "tim")
124 }
125 if _, _, err := m.Add("x", "tim"); err != ErrTooMany {
126 t.Fatal(err)
127 }
128}
129
130func TestLegacySingleConn(t *testing.T) {
131 d := t.TempDir()
132 key := "bgbk_" + strings.Repeat("ab", 32)
133 old := `{"key_hash":"` + HashKey(key) + `","sign_secret":"` + SigningSecret(key) + `","key_hint":"bgbk_ababab","server_url":"http://b:8080"}`
134 _ = os.WriteFile(filepath.Join(d, "backup.json"), []byte(old), 0o600)
135 m := &Manager{Dir: d}
136 c, ok := m.Check(key)
137 if !ok || c.ID == "" || c.Name != "backup" || !c.Connected() {
138 t.Fatalf("%+v %v", c, ok)
139 }
140}
141
142func TestCleanLogical(t *testing.T) {
143 good := []string{"state/bluegit.db", "state/secret.key", "state/ssh/host_ed25519", "data/repos/tim/a.git/HEAD", "data/releases/tim/a/v1/x.tgz"}
144 bad := []string{"", "/etc/passwd", "state/../x", "state/storage_path", "state/backup.json", "state/instance_id", "data/work/1/x", "data/releases/.incoming/x", "data/repos", "state/ssh", "x/y", "data/repos/../../etc", "state//secret.key", "data\\repos\\x"}
145 for _, p := range good {
146 if _, ok := CleanLogical(p); !ok {
147 t.Errorf("geweigerd: %s", p)
148 }
149 }
150 for _, p := range bad {
151 if _, ok := CleanLogical(p); ok {
152 t.Errorf("toegestaan: %s", p)
153 }
154 }
155}
156
157func write(t *testing.T, p, s string) {
158 t.Helper()
159 if err := os.MkdirAll(filepath.Dir(p), 0o755); err != nil {
160 t.Fatal(err)
161 }
162 if err := os.WriteFile(p, []byte(s), 0o644); err != nil {
163 t.Fatal(err)
164 }
165}
166
167func fakeTree(t *testing.T) Tree {
168 st, data := t.TempDir(), t.TempDir()
169 write(t, filepath.Join(st, "bluegit.db"), "live-db")
170 write(t, filepath.Join(st, "secret.key"), "k")
171 write(t, filepath.Join(st, "storage_path"), data)
172 write(t, filepath.Join(st, "backup.json"), "{}")
173 write(t, filepath.Join(st, "ssh", "host_ed25519"), "hk")
174 write(t, filepath.Join(data, "repos", "tim", "a.git", "HEAD"), "ref: refs/heads/master")
175 write(t, filepath.Join(data, "repos", "tim", "a.git", "index.lock"), "x")
176 write(t, filepath.Join(data, "releases", ".incoming", "x"), "x")
177 write(t, filepath.Join(data, "releases", "tim", "a", "v1", "a.bin"), "bin")
178 write(t, filepath.Join(data, "work", "1", "f"), "x")
179 _ = os.Symlink("/etc/passwd", filepath.Join(data, "repos", "tim", "evil"))
180 return Tree{StateDir: st, DataDir: data, Snapshot: func(dst string) error {
181 return os.WriteFile(dst, []byte("snapshot-db"), 0o600)
182 }}
183}
184
185func TestManifestAndResolve(t *testing.T) {
186 tr := fakeTree(t)
187 m, err := tr.Build("inst")
188 if err != nil {
189 t.Fatal(err)
190 }
191 var paths []string
192 for _, e := range m.Files {
193 paths = append(paths, e.Path)
194 }
195 got := strings.Join(paths, ",")
196 want := "data/releases/tim/a/v1/a.bin,data/repos/tim/a.git/HEAD,state/bluegit.db,state/secret.key,state/ssh/host_ed25519"
197 if got != want {
198 t.Fatalf("manifest\n got %s\nwant %s", got, want)
199 }
200 if m.Files[2].SHA256 == "" {
201 t.Fatal("database zonder hash")
202 }
203 p, err := tr.Resolve(DBPath)
204 if err != nil {
205 t.Fatal(err)
206 }
207 if b, _ := os.ReadFile(p); string(b) != "snapshot-db" {
208 t.Fatalf("database komt niet uit de kopie: %s", b)
209 }
210 for _, bad := range []string{"state/storage_path", "data/repos/tim/evil", "data/repos/../../etc/passwd"} {
211 if _, err := tr.Resolve(bad); err == nil {
212 t.Errorf("resolve %s toegestaan", bad)
213 }
214 }
215}
216
217type tf struct {
218 name, body string
219 typ byte
220}
221
222func tgz(t *testing.T, files []tf) []byte {
223 var buf bytes.Buffer
224 gz := gzip.NewWriter(&buf)
225 tw := tar.NewWriter(gz)
226 for _, f := range files {
227 typ := f.typ
228 if typ == 0 {
229 typ = tar.TypeReg
230 }
231 h := &tar.Header{Name: f.name, Mode: 0o644, Size: int64(len(f.body)), Typeflag: typ, ModTime: time.Unix(1_700_000_000, 0)}
232 if typ == tar.TypeSymlink {
233 h.Size, h.Linkname = 0, "/etc/passwd"
234 }
235 if err := tw.WriteHeader(h); err != nil {
236 t.Fatal(err)
237 }
238 if typ == tar.TypeReg {
239 _, _ = tw.Write([]byte(f.body))
240 }
241 }
242 tw.Close()
243 gz.Close()
244 return buf.Bytes()
245}
246
247func TestStageAndApply(t *testing.T) {
248 tr := fakeTree(t)
249 archive := tgz(t, []tf{
250 {name: "state/bluegit.db", body: "old-db"},
251 {name: "state/secret.key", body: "old-key"},
252 {name: "data/repos/tim/b.git/HEAD", body: "ref: refs/heads/main"},
253 })
254 n, err := tr.Stage(bytes.NewReader(archive))
255 if err != nil || n != 3 {
256 t.Fatal(n, err)
257 }
258 if b, _ := os.ReadFile(filepath.Join(tr.StateDir, "bluegit.db")); string(b) != "live-db" {
259 t.Fatal("stage raakte de live database")
260 }
261 if !HasPending(tr.StateDir) {
262 t.Fatal("geen READY")
263 }
264 ok, err := ApplyPending(tr.StateDir)
265 if err != nil || !ok {
266 t.Fatal(ok, err)
267 }
268 check := func(p, want string) {
269 t.Helper()
270 b, err := os.ReadFile(p)
271 if want == "" {
272 if err == nil {
273 t.Errorf("%s bestaat nog", p)
274 }
275 return
276 }
277 if string(b) != want {
278 t.Errorf("%s = %q, wil %q", p, b, want)
279 }
280 }
281 check(filepath.Join(tr.StateDir, "bluegit.db"), "old-db")
282 check(filepath.Join(tr.StateDir, "secret.key"), "old-key")
283 check(filepath.Join(tr.StateDir, "ssh", "host_ed25519"), "")
284 check(filepath.Join(tr.StateDir, "backup.json"), "{}")
285 check(filepath.Join(tr.StateDir, "storage_path"), tr.DataDir)
286 check(filepath.Join(tr.DataDir, "repos", "tim", "b.git", "HEAD"), "ref: refs/heads/main")
287 check(filepath.Join(tr.DataDir, "repos", "tim", "a.git", "HEAD"), "")
288 check(filepath.Join(tr.DataDir, "releases", "tim", "a", "v1", "a.bin"), "")
289 check(filepath.Join(tr.DataDir, "work", "1", "f"), "x")
290 if HasPending(tr.StateDir) {
291 t.Fatal("READY blijft staan")
292 }
293 if ok, _ := ApplyPending(tr.StateDir); ok {
294 t.Fatal("tweede keer toegepast")
295 }
296}
297
298func TestStageRejects(t *testing.T) {
299 cases := map[string][]tf{
300 "traversal": {{name: "state/bluegit.db", body: "x"}, {name: "state/secret.key", body: "k"}, {name: "data/repos/../../../etc/x", body: "x"}},
301 "symlink": {{name: "state/bluegit.db", body: "x"}, {name: "state/secret.key", body: "k"}, {name: "data/repos/a/l", typ: tar.TypeSymlink}},
302 "onbekend": {{name: "state/bluegit.db", body: "x"}, {name: "state/secret.key", body: "k"}, {name: "state/storage_path", body: "/"}},
303 "zonder-db": {{name: "state/secret.key", body: "k"}},
304 "zonder-key": {{name: "state/bluegit.db", body: "x"}},
305 }
306 for name, files := range cases {
307 tr := fakeTree(t)
308 if _, err := tr.Stage(bytes.NewReader(tgz(t, files))); err == nil {
309 t.Errorf("%s: geaccepteerd", name)
310 }
311 if HasPending(tr.StateDir) {
312 t.Errorf("%s: READY na fout", name)
313 }
314 if _, err := os.Stat(filepath.Join(tr.StateDir, ".restore")); err == nil {
315 t.Errorf("%s: staging blijft staan", name)
316 }
317 }
318 if _, err := fakeTree(t).Stage(strings.NewReader("geen gzip")); err == nil {
319 t.Error("geen gzip geaccepteerd")
320 }
321}
322
323// Vaste vector: bluegit-backup (internal/protocol) test dezelfde waarden.
324func TestSignatureVector(t *testing.T) {
325 sec := SigningSecret("bgbk_test")
326 if sec != "c04d0bdbac2260c010f61c9b063b28026eed1d2292c928708708821449e72c2a" {
327 t.Fatalf("geheim %s", sec)
328 }
329 if got := Signature(sec, "post", "/api/v1/notify", "1800000000", []byte("{}")); got != "51c5ec72528304632383637b99dfda1e14b68194bbec2d4faa36c9d5ef892548" {
330 t.Fatalf("handtekening %s", got)
331 }
332}
333
334// Twee backup servers die tegelijk een manifest ophalen krijgen elk hun
335// eigen databasekopie; de ene vervangt de kopie van de andere niet.
336func TestSnapshotPerConnection(t *testing.T) {
337 base := fakeTree(t)
338 var mu sync.Mutex
339 busy := 0
340 n := 0
341 base.Snapshot = func(dst string) error {
342 mu.Lock()
343 busy++
344 n++
345 if busy > 1 {
346 mu.Unlock()
347 return errors.New("twee kopieën tegelijk")
348 }
349 body := fmt.Sprintf("snapshot-%d", n)
350 mu.Unlock()
351 time.Sleep(5 * time.Millisecond)
352 err := os.WriteFile(dst, []byte(body), 0o600)
353 mu.Lock()
354 busy--
355 mu.Unlock()
356 return err
357 }
358 a, b := base, base
359 a.Conn, b.Conn = "aaa", "bbb"
360 var wg sync.WaitGroup
361 errs := make(chan error, 20)
362 for i := 0; i < 10; i++ {
363 for _, tr := range []Tree{a, b} {
364 wg.Add(1)
365 go func(tr Tree) {
366 defer wg.Done()
367 if _, err := tr.Build("inst"); err != nil {
368 errs <- err
369 }
370 }(tr)
371 }
372 }
373 wg.Wait()
374 close(errs)
375 for err := range errs {
376 t.Fatal(err)
377 }
378 ma, err := a.Build("inst")
379 if err != nil {
380 t.Fatal(err)
381 }
382 if _, err := b.Build("inst"); err != nil {
383 t.Fatal(err)
384 }
385 // De kopie van a is niet veranderd door de build van b.
386 p, _ := a.Resolve(DBPath)
387 raw, _ := os.ReadFile(p)
388 sum := sha256.Sum256(raw)
389 for _, e := range ma.Files {
390 if e.Path == DBPath && e.SHA256 != hex.EncodeToString(sum[:]) {
391 t.Fatal("kopie van a is overschreven door b")
392 }
393 }
394 a.RemoveSnapshot()
395 if _, err := a.Resolve(DBPath); err == nil {
396 t.Fatal("kopie niet opgeruimd")
397 }
398 if _, err := b.Resolve(DBPath); err != nil {
399 t.Fatal("kopie van b is mee opgeruimd")
400 }
401}