BlueGit

timfa bluegit

Files

bluegit / internal / backup / backup_test.go

backup_test.go

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