| 1 | package server |
| 2 | |
| 3 | import ( |
| 4 | "bytes" |
| 5 | "encoding/json" |
| 6 | "net/http" |
| 7 | "net/http/httptest" |
| 8 | "net/url" |
| 9 | "os" |
| 10 | "path/filepath" |
| 11 | "regexp" |
| 12 | "strings" |
| 13 | "testing" |
| 14 | "time" |
| 15 | |
| 16 | "git.timfalken.com/timfa/bluegit-backup/internal/config" |
| 17 | "git.timfalken.com/timfa/bluegit-backup/internal/protocol" |
| 18 | ) |
| 19 | |
| 20 | // uiClient is een browser met een cookie. |
| 21 | type uiClient struct { |
| 22 | t *testing.T |
| 23 | h http.Handler |
| 24 | cookie *http.Cookie |
| 25 | } |
| 26 | |
| 27 | func (c *uiClient) do(method, p string, form url.Values) *httptest.ResponseRecorder { |
| 28 | var body *strings.Reader |
| 29 | if form != nil { |
| 30 | body = strings.NewReader(form.Encode()) |
| 31 | } else { |
| 32 | body = strings.NewReader("") |
| 33 | } |
| 34 | r := httptest.NewRequest(method, p, body) |
| 35 | if form != nil { |
| 36 | r.Header.Set("Content-Type", "application/x-www-form-urlencoded") |
| 37 | } |
| 38 | if c.cookie != nil { |
| 39 | r.AddCookie(c.cookie) |
| 40 | } |
| 41 | w := httptest.NewRecorder() |
| 42 | c.h.ServeHTTP(w, r) |
| 43 | for _, ck := range w.Result().Cookies() { |
| 44 | if ck.Name == sessionCookie { |
| 45 | c.cookie = ck |
| 46 | } |
| 47 | } |
| 48 | return w |
| 49 | } |
| 50 | |
| 51 | var csrfRE = regexp.MustCompile(`name="csrf" value="([0-9a-f]+)"`) |
| 52 | |
| 53 | func login(t *testing.T, s *Server) (*uiClient, string) { |
| 54 | c := &uiClient{t: t, h: s.Handler()} |
| 55 | if w := c.do("GET", "/", nil); w.Code != 303 || w.Header().Get("Location") != "/login" { |
| 56 | t.Fatalf("zonder sessie: %d %s", w.Code, w.Header().Get("Location")) |
| 57 | } |
| 58 | if w := c.do("POST", "/login", url.Values{"token": {"fout"}}); w.Header().Get("Location") != "/login?fout=1" { |
| 59 | t.Fatalf("fout token: %s", w.Header().Get("Location")) |
| 60 | } |
| 61 | if w := c.do("POST", "/login", url.Values{"token": {s.AdminToken()}}); w.Code != 303 || c.cookie == nil { |
| 62 | t.Fatalf("login %d", w.Code) |
| 63 | } |
| 64 | if !c.cookie.HttpOnly || c.cookie.SameSite != http.SameSiteStrictMode { |
| 65 | t.Fatalf("cookie %+v", c.cookie) |
| 66 | } |
| 67 | w := c.do("GET", "/", nil) |
| 68 | if w.Code != 200 { |
| 69 | t.Fatalf("index %d", w.Code) |
| 70 | } |
| 71 | m := csrfRE.FindStringSubmatch(w.Body.String()) |
| 72 | if m == nil { |
| 73 | t.Fatal("geen csrf") |
| 74 | } |
| 75 | return c, m[1] |
| 76 | } |
| 77 | |
| 78 | // Elke wijzigende actie heeft een formulier in de webinterface, elke |
| 79 | // beheerroute zit in Actions, en elk formulier hoort bij een actie. |
| 80 | func TestUIAndAPIParity(t *testing.T) { |
| 81 | f := newFake(t) |
| 82 | s := newTestServer(t) |
| 83 | if w := adminReq(s, "POST", "/api/v1/admin/connect", `{"url":"`+f.ts.URL+`","key":"bgbk_test"}`); w.Code != 200 { |
| 84 | t.Fatal(w.Body) |
| 85 | } |
| 86 | if _, err := s.SyncNow(t.Context()); err != nil { |
| 87 | t.Fatal(err) |
| 88 | } |
| 89 | if _, err := s.ArchiveNow(); err != nil { |
| 90 | t.Fatal(err) |
| 91 | } |
| 92 | c, _ := login(t, s) |
| 93 | page := c.do("GET", "/", nil).Body.String() |
| 94 | // Het koppelformulier staat in een uitklapper zodra er gekoppeld is; het |
| 95 | // moet er nog steeds zijn. |
| 96 | forms := map[string]bool{} |
| 97 | for _, m := range regexp.MustCompile(`action="/ui/act/([a-z.]+)"`).FindAllStringSubmatch(page, -1) { |
| 98 | forms[m[1]] = true |
| 99 | } |
| 100 | for _, a := range s.Actions() { |
| 101 | switch a.Method { |
| 102 | case "GET": |
| 103 | // Getoond op de pagina; download als link. |
| 104 | if a.Name == "archive.download" && !strings.Contains(page, "/download\">Downloaden") { |
| 105 | t.Errorf("geen downloadlink") |
| 106 | } |
| 107 | default: |
| 108 | if !forms[a.Name] { |
| 109 | t.Errorf("actie %s (%s %s) heeft geen formulier in de webinterface", a.Name, a.Method, a.Path) |
| 110 | } |
| 111 | delete(forms, a.Name) |
| 112 | } |
| 113 | } |
| 114 | for f := range forms { |
| 115 | t.Errorf("formulier %s hoort bij geen API-actie", f) |
| 116 | } |
| 117 | // Alle GET-acties geven hun gegevens ook op de pagina. |
| 118 | for _, want := range []string{"Overzicht", "cfg-archive_interval", "cfg-listen", "bluegit-", "/api/v1/admin/config"} { |
| 119 | if !strings.Contains(page, want) { |
| 120 | t.Errorf("pagina mist %q", want) |
| 121 | } |
| 122 | } |
| 123 | // De API geeft dezelfde actielijst. |
| 124 | w := adminReq(s, "GET", "/api/v1/admin/actions", "") |
| 125 | var al struct { |
| 126 | Actions []Action `json:"actions"` |
| 127 | } |
| 128 | _ = json.Unmarshal(w.Body.Bytes(), &al) |
| 129 | if len(al.Actions) != len(s.Actions()) { |
| 130 | t.Fatalf("actions %d", len(al.Actions)) |
| 131 | } |
| 132 | } |
| 133 | |
| 134 | func TestUISettingsAndCSRF(t *testing.T) { |
| 135 | s := newTestServer(t) |
| 136 | c, csrf := login(t, s) |
| 137 | form := url.Values{"csrf": {csrf}, "retention_days": {"9"}, "archive_interval": {"12h"}, "rate_limit_kib": {"300"}, "listen": {"127.0.0.1:9999"}} |
| 138 | if w := c.do("POST", "/ui/act/config.update", form); w.Code != 303 { |
| 139 | t.Fatalf("opslaan %d %s", w.Code, w.Body) |
| 140 | } |
| 141 | page := c.do("GET", "/", nil).Body.String() |
| 142 | if !strings.Contains(page, "Instellingen opgeslagen") || !strings.Contains(page, "herstart") { |
| 143 | t.Fatalf("melding ontbreekt") |
| 144 | } |
| 145 | cv := s.ConfigView() |
| 146 | get := func(k string) string { |
| 147 | for _, f := range cv.Fields { |
| 148 | if f.Key == k { |
| 149 | return f.Value |
| 150 | } |
| 151 | } |
| 152 | return "" |
| 153 | } |
| 154 | if get("retention_days") != "9" || get("archive_interval") != "12h" || get("listen") != "127.0.0.1:9999" || !cv.Restart { |
| 155 | t.Fatalf("%+v", cv) |
| 156 | } |
| 157 | if s.limiter.Rate() != 300<<10 { |
| 158 | t.Fatalf("rate %d", s.limiter.Rate()) |
| 159 | } |
| 160 | if s.cfg().Listen == "127.0.0.1:9999" { |
| 161 | t.Fatal("listen hoort pas na herstart te gelden") |
| 162 | } |
| 163 | // Bewaard: een nieuwe server leest het. |
| 164 | s2, err := New(s.Cfg, nil) |
| 165 | if err != nil { |
| 166 | t.Fatal(err) |
| 167 | } |
| 168 | if s2.cfg().RetentionDays != 9 || s2.cfg().Listen != "127.0.0.1:9999" { |
| 169 | t.Fatalf("na herstart %+v", s2.cfg()) |
| 170 | } |
| 171 | // Zonder of met fout CSRF-token: geweigerd. |
| 172 | if w := c.do("POST", "/ui/act/config.update", url.Values{"retention_days": {"1"}}); w.Code != 403 { |
| 173 | t.Fatalf("zonder csrf %d", w.Code) |
| 174 | } |
| 175 | // Ongeldige waarde: foutmelding, niets veranderd. |
| 176 | c.do("POST", "/ui/act/config.update", url.Values{"csrf": {csrf}, "retention_days": {"-1"}}) |
| 177 | if !strings.Contains(c.do("GET", "/", nil).Body.String(), "mislukt") || s.cfg().RetentionDays != 9 { |
| 178 | t.Fatal("ongeldige waarde") |
| 179 | } |
| 180 | // API met sessiecookie vraagt X-CSRF-Token. |
| 181 | r := httptest.NewRequest("PUT", "/api/v1/admin/config", strings.NewReader(`{"retention_days":3}`)) |
| 182 | r.AddCookie(c.cookie) |
| 183 | w := httptest.NewRecorder() |
| 184 | s.Handler().ServeHTTP(w, r) |
| 185 | if w.Code != 403 { |
| 186 | t.Fatalf("cookie zonder csrf-header %d", w.Code) |
| 187 | } |
| 188 | r = httptest.NewRequest("PUT", "/api/v1/admin/config", strings.NewReader(`{"retention_days":3}`)) |
| 189 | r.AddCookie(c.cookie) |
| 190 | r.Header.Set("X-CSRF-Token", csrf) |
| 191 | w = httptest.NewRecorder() |
| 192 | s.Handler().ServeHTTP(w, r) |
| 193 | if w.Code != 200 || s.cfg().RetentionDays != 3 { |
| 194 | t.Fatalf("cookie met csrf-header %d %s", w.Code, w.Body) |
| 195 | } |
| 196 | // Uitloggen. |
| 197 | c.do("POST", "/logout", url.Values{"csrf": {csrf}}) |
| 198 | if w := c.do("GET", "/", nil); w.Code != 303 { |
| 199 | t.Fatalf("na uitloggen %d", w.Code) |
| 200 | } |
| 201 | // Webinterface mag niet in een iframe van een ander. |
| 202 | if h := c.do("GET", "/login", nil).Header(); h.Get("X-Frame-Options") != "DENY" { |
| 203 | t.Fatal("frame") |
| 204 | } |
| 205 | } |
| 206 | |
| 207 | func TestLoginRateLimit(t *testing.T) { |
| 208 | s := newTestServer(t) |
| 209 | c := &uiClient{t: t, h: s.Handler()} |
| 210 | for i := 0; i < 5; i++ { |
| 211 | c.do("POST", "/login", url.Values{"token": {"fout"}}) |
| 212 | } |
| 213 | if w := c.do("POST", "/login", url.Values{"token": {s.AdminToken()}}); w.Code != 429 { |
| 214 | t.Fatalf("na 5 fouten %d", w.Code) |
| 215 | } |
| 216 | } |
| 217 | |
| 218 | func TestAPIConfig(t *testing.T) { |
| 219 | s := newTestServer(t) |
| 220 | w := adminReq(s, "PUT", "/api/v1/admin/config", `{"min_free_mb":2048,"full_sync_interval":"30m"}`) |
| 221 | if w.Code != 200 { |
| 222 | t.Fatalf("%d %s", w.Code, w.Body) |
| 223 | } |
| 224 | if s.cfg().MinFreeMB != 2048 || s.cfg().FullSyncInterval.Duration != 30*time.Minute { |
| 225 | t.Fatalf("%+v", s.cfg()) |
| 226 | } |
| 227 | if _, err := os.Stat(filepath.Join(s.Cfg.DataDir, config.SettingsFile)); err != nil { |
| 228 | t.Fatal(err) |
| 229 | } |
| 230 | for _, body := range []string{`{"data_dir":"/tmp"}`, `{"onbekend":1}`, `{"archive_interval":"0s"}`, `{}`, `[1]`} { |
| 231 | if w := adminReq(s, "PUT", "/api/v1/admin/config", body); w.Code != 400 { |
| 232 | t.Errorf("%s: %d", body, w.Code) |
| 233 | } |
| 234 | } |
| 235 | w = adminReq(s, "GET", "/api/v1/admin/config", "") |
| 236 | var cv ConfigView |
| 237 | _ = json.Unmarshal(w.Body.Bytes(), &cv) |
| 238 | if len(cv.Fields) != len(config.Fields) { |
| 239 | t.Fatalf("%s", w.Body) |
| 240 | } |
| 241 | } |
| 242 | |
| 243 | func TestSignedAdminActions(t *testing.T) { |
| 244 | f := newFake(t) |
| 245 | s := newTestServer(t) |
| 246 | if w := adminReq(s, "POST", "/api/v1/admin/connect", `{"url":"`+f.ts.URL+`","key":"bgbk_test"}`); w.Code != 200 { |
| 247 | t.Fatal(w.Body) |
| 248 | } |
| 249 | good := protocol.SigningSecret("bgbk_test") |
| 250 | call := func(method, p, body string) *httptest.ResponseRecorder { |
| 251 | r := httptest.NewRequest(method, p, bytes.NewReader([]byte(body))) |
| 252 | protocol.Sign(r, good, "inst-1", []byte(body), time.Now()) |
| 253 | w := httptest.NewRecorder() |
| 254 | s.Handler().ServeHTTP(w, r) |
| 255 | return w |
| 256 | } |
| 257 | if w := call("PUT", "/api/v1/admin/config", `{"retention_days":"4"}`); w.Code != 200 || s.cfg().RetentionDays != 4 { |
| 258 | t.Fatalf("config via BlueGit %d %s", w.Code, w.Body) |
| 259 | } |
| 260 | if w := call("GET", "/api/v1/admin/config", ""); w.Code != 200 { |
| 261 | t.Fatalf("config lezen %d", w.Code) |
| 262 | } |
| 263 | if w := call("POST", "/api/v1/admin/connect", `{}`); w.Code != 403 { |
| 264 | t.Fatalf("connect via BlueGit %d", w.Code) |
| 265 | } |
| 266 | if w := call("POST", "/api/v1/admin/rollback", `{"archive":"bluegit-20261115-120000.tar.gz"}`); w.Code != 400 { |
| 267 | t.Fatalf("rollback zonder confirm %d", w.Code) |
| 268 | } |
| 269 | // Handtekening over een ander pad: geweigerd. |
| 270 | r := httptest.NewRequest("POST", "/api/v1/admin/sync", nil) |
| 271 | protocol.Sign(r, good, "inst-1", nil, time.Now()) |
| 272 | r.URL.Path = "/api/v1/admin/disconnect" |
| 273 | w := httptest.NewRecorder() |
| 274 | s.Handler().ServeHTTP(w, r) |
| 275 | if w.Code != 401 { |
| 276 | t.Fatalf("ander pad %d", w.Code) |
| 277 | } |
| 278 | if w := call("POST", "/api/v1/admin/disconnect", ``); w.Code != 200 || s.getState().Connected() { |
| 279 | t.Fatalf("disconnect %d", w.Code) |
| 280 | } |
| 281 | // Ontkoppeld: BlueGit kan niets meer. |
| 282 | if w := call("GET", "/api/v1/admin/status", ""); w.Code != 401 { |
| 283 | t.Fatalf("na ontkoppelen %d", w.Code) |
| 284 | } |
| 285 | } |