package backup import ( "archive/tar" "bytes" "compress/gzip" "net/http" "os" "path/filepath" "strings" "testing" "time" ) func TestSignVerify(t *testing.T) { sec := SigningSecret("bgbk_x") now := time.Unix(1_800_000_000, 0) body := []byte(`{"archive":"a"}`) req, _ := http.NewRequest("POST", "http://b/api/v1/rollback", bytes.NewReader(body)) Sign(req, sec, "inst", body, now) if err := Verify(req, sec, body, now.Add(time.Minute)); err != nil { t.Fatal(err) } if Verify(req, sec, []byte(`{"archive":"b"}`), now) == nil { t.Fatal("andere body geaccepteerd") } if Verify(req, SigningSecret("bgbk_y"), body, now) == nil { t.Fatal("ander geheim geaccepteerd") } if Verify(req, sec, body, now.Add(10*time.Minute)) == nil { t.Fatal("oude timestamp geaccepteerd") } req.URL.Path = "/api/v1/notify" if Verify(req, sec, body, now) == nil { t.Fatal("ander pad geaccepteerd") } } func TestKeyLifecycle(t *testing.T) { m := &Manager{Dir: t.TempDir()} if _, ok := m.Check("bgbk_nope"); ok { t.Fatal("check zonder key") } key, c, err := m.Add(" nas kelder ", "tim") if err != nil || !strings.HasPrefix(key, KeyPrefix) || c.KeyHash == "" || c.Name != "nas kelder" || c.ID == "" { t.Fatal(key, c, err) } raw, _ := os.ReadFile(filepath.Join(m.Dir, "backup.json")) if strings.Contains(string(raw), key) { t.Fatal("key staat leesbaar op schijf") } fi, _ := os.Stat(filepath.Join(m.Dir, "backup.json")) if fi.Mode().Perm() != 0o600 { t.Fatalf("mode %v", fi.Mode()) } if got, ok := m.Check(key); !ok || got.ID != c.ID { t.Fatal("eigen key geweigerd") } if _, err := m.Connect(c.ID, "http://backup:9000/", "srv1"); err != nil { t.Fatal(err) } c, _ = m.Get(c.ID) if !c.Connected() || c.ServerURL != "http://backup:9000" || c.SignSecret != SigningSecret(key) { t.Fatalf("%+v", c) } // Een tweede backup server met een eigen key; de eerste blijft werken. keyB, b, err := m.Add("offsite", "tim") if err != nil { t.Fatal(err) } if got, ok := m.Check(keyB); !ok || got.ID != b.ID { t.Fatal("tweede key") } if got, ok := m.Check(key); !ok || got.ID != c.ID { t.Fatal("eerste key werkt niet meer") } if list, _ := m.List(); len(list) != 2 { t.Fatalf("%d servers", len(list)) } // Nieuwe key voor de eerste: oude key dood, koppeling weg, tweede blijft. key2, _, err := m.RotateKey(c.ID, "tim") if err != nil { t.Fatal(err) } if _, ok := m.Check(key); ok { t.Fatal("oude key werkt nog") } if _, ok := m.Check(key2); !ok { t.Fatal("nieuwe key geweigerd") } if c, _ := m.Get(c.ID); c.Connected() { t.Fatal("nieuwe key houdt oude server vast") } if _, err := m.Rename(b.ID, "Offsite 2"); err != nil { t.Fatal(err) } if b, _ := m.Get(b.ID); b.Name != "Offsite 2" { t.Fatal(b.Name) } id1, _ := m.InstanceID() id2, _ := m.InstanceID() if id1 == "" || id1 != id2 { t.Fatal("instance-id niet vast") } if err := m.Remove(c.ID); err != nil { t.Fatal(err) } if _, ok := m.Check(key2); ok { t.Fatal("ingetrokken key werkt") } if _, ok := m.Check(keyB); !ok { t.Fatal("andere server verloor zijn key") } if err := m.Remove("bestaatniet"); err != ErrUnknown { t.Fatal(err) } for i := 0; i < MaxServers; i++ { _, _, _ = m.Add("x", "tim") } if _, _, err := m.Add("x", "tim"); err != ErrTooMany { t.Fatal(err) } } func TestLegacySingleConn(t *testing.T) { d := t.TempDir() key := "bgbk_" + strings.Repeat("ab", 32) old := `{"key_hash":"` + HashKey(key) + `","sign_secret":"` + SigningSecret(key) + `","key_hint":"bgbk_ababab","server_url":"http://b:8080"}` _ = os.WriteFile(filepath.Join(d, "backup.json"), []byte(old), 0o600) m := &Manager{Dir: d} c, ok := m.Check(key) if !ok || c.ID == "" || c.Name != "backup" || !c.Connected() { t.Fatalf("%+v %v", c, ok) } } func TestCleanLogical(t *testing.T) { 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"} 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"} for _, p := range good { if _, ok := CleanLogical(p); !ok { t.Errorf("geweigerd: %s", p) } } for _, p := range bad { if _, ok := CleanLogical(p); ok { t.Errorf("toegestaan: %s", p) } } } func write(t *testing.T, p, s string) { t.Helper() if err := os.MkdirAll(filepath.Dir(p), 0o755); err != nil { t.Fatal(err) } if err := os.WriteFile(p, []byte(s), 0o644); err != nil { t.Fatal(err) } } func fakeTree(t *testing.T) Tree { st, data := t.TempDir(), t.TempDir() write(t, filepath.Join(st, "bluegit.db"), "live-db") write(t, filepath.Join(st, "secret.key"), "k") write(t, filepath.Join(st, "storage_path"), data) write(t, filepath.Join(st, "backup.json"), "{}") write(t, filepath.Join(st, "ssh", "host_ed25519"), "hk") write(t, filepath.Join(data, "repos", "tim", "a.git", "HEAD"), "ref: refs/heads/master") write(t, filepath.Join(data, "repos", "tim", "a.git", "index.lock"), "x") write(t, filepath.Join(data, "releases", ".incoming", "x"), "x") write(t, filepath.Join(data, "releases", "tim", "a", "v1", "a.bin"), "bin") write(t, filepath.Join(data, "work", "1", "f"), "x") _ = os.Symlink("/etc/passwd", filepath.Join(data, "repos", "tim", "evil")) return Tree{StateDir: st, DataDir: data, Snapshot: func(dst string) error { return os.WriteFile(dst, []byte("snapshot-db"), 0o600) }} } func TestManifestAndResolve(t *testing.T) { tr := fakeTree(t) m, err := tr.Build("inst") if err != nil { t.Fatal(err) } var paths []string for _, e := range m.Files { paths = append(paths, e.Path) } got := strings.Join(paths, ",") want := "data/releases/tim/a/v1/a.bin,data/repos/tim/a.git/HEAD,state/bluegit.db,state/secret.key,state/ssh/host_ed25519" if got != want { t.Fatalf("manifest\n got %s\nwant %s", got, want) } if m.Files[2].SHA256 == "" { t.Fatal("database zonder hash") } p, err := tr.Resolve(DBPath) if err != nil { t.Fatal(err) } if b, _ := os.ReadFile(p); string(b) != "snapshot-db" { t.Fatalf("database komt niet uit de kopie: %s", b) } for _, bad := range []string{"state/storage_path", "data/repos/tim/evil", "data/repos/../../etc/passwd"} { if _, err := tr.Resolve(bad); err == nil { t.Errorf("resolve %s toegestaan", bad) } } } type tf struct { name, body string typ byte } func tgz(t *testing.T, files []tf) []byte { var buf bytes.Buffer gz := gzip.NewWriter(&buf) tw := tar.NewWriter(gz) for _, f := range files { typ := f.typ if typ == 0 { typ = tar.TypeReg } h := &tar.Header{Name: f.name, Mode: 0o644, Size: int64(len(f.body)), Typeflag: typ, ModTime: time.Unix(1_700_000_000, 0)} if typ == tar.TypeSymlink { h.Size, h.Linkname = 0, "/etc/passwd" } if err := tw.WriteHeader(h); err != nil { t.Fatal(err) } if typ == tar.TypeReg { _, _ = tw.Write([]byte(f.body)) } } tw.Close() gz.Close() return buf.Bytes() } func TestStageAndApply(t *testing.T) { tr := fakeTree(t) archive := tgz(t, []tf{ {name: "state/bluegit.db", body: "old-db"}, {name: "state/secret.key", body: "old-key"}, {name: "data/repos/tim/b.git/HEAD", body: "ref: refs/heads/main"}, }) n, err := tr.Stage(bytes.NewReader(archive)) if err != nil || n != 3 { t.Fatal(n, err) } if b, _ := os.ReadFile(filepath.Join(tr.StateDir, "bluegit.db")); string(b) != "live-db" { t.Fatal("stage raakte de live database") } if !HasPending(tr.StateDir) { t.Fatal("geen READY") } ok, err := ApplyPending(tr.StateDir) if err != nil || !ok { t.Fatal(ok, err) } check := func(p, want string) { t.Helper() b, err := os.ReadFile(p) if want == "" { if err == nil { t.Errorf("%s bestaat nog", p) } return } if string(b) != want { t.Errorf("%s = %q, wil %q", p, b, want) } } check(filepath.Join(tr.StateDir, "bluegit.db"), "old-db") check(filepath.Join(tr.StateDir, "secret.key"), "old-key") check(filepath.Join(tr.StateDir, "ssh", "host_ed25519"), "") check(filepath.Join(tr.StateDir, "backup.json"), "{}") check(filepath.Join(tr.StateDir, "storage_path"), tr.DataDir) check(filepath.Join(tr.DataDir, "repos", "tim", "b.git", "HEAD"), "ref: refs/heads/main") check(filepath.Join(tr.DataDir, "repos", "tim", "a.git", "HEAD"), "") check(filepath.Join(tr.DataDir, "releases", "tim", "a", "v1", "a.bin"), "") check(filepath.Join(tr.DataDir, "work", "1", "f"), "x") if HasPending(tr.StateDir) { t.Fatal("READY blijft staan") } if ok, _ := ApplyPending(tr.StateDir); ok { t.Fatal("tweede keer toegepast") } } func TestStageRejects(t *testing.T) { cases := map[string][]tf{ "traversal": {{name: "state/bluegit.db", body: "x"}, {name: "state/secret.key", body: "k"}, {name: "data/repos/../../../etc/x", body: "x"}}, "symlink": {{name: "state/bluegit.db", body: "x"}, {name: "state/secret.key", body: "k"}, {name: "data/repos/a/l", typ: tar.TypeSymlink}}, "onbekend": {{name: "state/bluegit.db", body: "x"}, {name: "state/secret.key", body: "k"}, {name: "state/storage_path", body: "/"}}, "zonder-db": {{name: "state/secret.key", body: "k"}}, "zonder-key": {{name: "state/bluegit.db", body: "x"}}, } for name, files := range cases { tr := fakeTree(t) if _, err := tr.Stage(bytes.NewReader(tgz(t, files))); err == nil { t.Errorf("%s: geaccepteerd", name) } if HasPending(tr.StateDir) { t.Errorf("%s: READY na fout", name) } if _, err := os.Stat(filepath.Join(tr.StateDir, ".restore")); err == nil { t.Errorf("%s: staging blijft staan", name) } } if _, err := fakeTree(t).Stage(strings.NewReader("geen gzip")); err == nil { t.Error("geen gzip geaccepteerd") } } // Vaste vector: bluegit-backup (internal/protocol) test dezelfde waarden. func TestSignatureVector(t *testing.T) { sec := SigningSecret("bgbk_test") if sec != "c04d0bdbac2260c010f61c9b063b28026eed1d2292c928708708821449e72c2a" { t.Fatalf("geheim %s", sec) } if got := Signature(sec, "post", "/api/v1/notify", "1800000000", []byte("{}")); got != "51c5ec72528304632383637b99dfda1e14b68194bbec2d4faa36c9d5ef892548" { t.Fatalf("handtekening %s", got) } }