package server import ( "crypto/rand" "crypto/subtle" "embed" "encoding/hex" "encoding/json" "fmt" "html/template" "net" "net/http" "net/url" "strings" "time" "git.timfalken.com/timfa/bluegit-backup/internal/archive" ) //go:embed web/* var webFS embed.FS var uiTmpl = template.Must(template.New("").Funcs(template.FuncMap{ "bytes": humanBytes, "when": func(t time.Time) string { if t.IsZero() { return "nog niet" } return t.Local().Format("2006-01-02 15:04:05") }, "json": func(v any) string { b, _ := json.MarshalIndent(v, "", " "); return string(b) }, }).ParseFS(webFS, "web/*.html")) const ( sessionCookie = "bbsession" sessionTTL = 12 * time.Hour ) type session struct { csrf string expires time.Time flash string isErr bool } func randHex(n int) string { b := make([]byte, n) _, _ = rand.Read(b) return hex.EncodeToString(b) } func humanBytes(n int64) string { const unit = 1024 if n < unit { return fmt.Sprintf("%d B", n) } div, exp := int64(unit), 0 for m := n / unit; m >= unit; m /= unit { div *= unit exp++ } return fmt.Sprintf("%.1f %ciB", float64(n)/float64(div), "KMGTPE"[exp]) } func (s *Server) session(r *http.Request) (session, bool) { c, err := r.Cookie(sessionCookie) if err != nil || c.Value == "" { return session{}, false } s.mu.Lock() defer s.mu.Unlock() sess, ok := s.sessions[c.Value] if !ok || s.now().After(sess.expires) { delete(s.sessions, c.Value) return session{}, false } return sess, true } func (s *Server) setFlash(r *http.Request, msg string, isErr bool) { c, err := r.Cookie(sessionCookie) if err != nil { return } s.mu.Lock() defer s.mu.Unlock() if sess, ok := s.sessions[c.Value]; ok { sess.flash, sess.isErr = msg, isErr s.sessions[c.Value] = sess } } func (s *Server) takeFlash(r *http.Request) (string, bool) { c, err := r.Cookie(sessionCookie) if err != nil { return "", false } s.mu.Lock() defer s.mu.Unlock() sess, ok := s.sessions[c.Value] if !ok { return "", false } msg, isErr := sess.flash, sess.isErr sess.flash, sess.isErr = "", false s.sessions[c.Value] = sess return msg, isErr } func clientIP(r *http.Request) string { h, _, err := net.SplitHostPort(r.RemoteAddr) if err != nil { return r.RemoteAddr } return h } // loginAllowed: hoogstens 5 foute pogingen per minuut per IP-adres. func (s *Server) loginAllowed(ip string, failed bool) bool { s.mu.Lock() defer s.mu.Unlock() if s.loginFails == nil { s.loginFails = map[string][]time.Time{} } cut := s.now().Add(-time.Minute) keep := s.loginFails[ip][:0] for _, t := range s.loginFails[ip] { if t.After(cut) { keep = append(keep, t) } } if failed { keep = append(keep, s.now()) } s.loginFails[ip] = keep return len(keep) < 5 } func (s *Server) mountUI(mux *http.ServeMux) { mux.HandleFunc("GET /{$}", s.uiIndex) mux.HandleFunc("GET /login", s.uiLoginPage) mux.HandleFunc("POST /login", s.uiLogin) mux.HandleFunc("POST /logout", s.uiLogout) mux.HandleFunc("POST /ui/act/{name}", s.uiAct) } func (s *Server) render(w http.ResponseWriter, name string, data any) { w.Header().Set("Content-Type", "text/html; charset=utf-8") w.Header().Set("Cache-Control", "no-store") w.Header().Set("Content-Security-Policy", "default-src 'self'; style-src 'self' 'unsafe-inline'; script-src 'none'; frame-ancestors 'none'; form-action 'self'") w.Header().Set("X-Frame-Options", "DENY") if err := uiTmpl.ExecuteTemplate(w, name, data); err != nil { s.Log.Error("template", "name", name, "err", err) } } func (s *Server) uiLoginPage(w http.ResponseWriter, r *http.Request) { if _, ok := s.session(r); ok { http.Redirect(w, r, "/", http.StatusSeeOther) return } s.render(w, "login.html", map[string]any{"Error": r.URL.Query().Get("fout") != "", "Version": Version}) } func (s *Server) uiLogin(w http.ResponseWriter, r *http.Request) { ip := clientIP(r) if !s.loginAllowed(ip, false) { http.Error(w, "te veel pogingen, wacht een minuut", http.StatusTooManyRequests) return } tok := strings.TrimSpace(r.PostFormValue("token")) if subtle.ConstantTimeCompare([]byte(tok), []byte(s.adminToken)) != 1 { s.loginAllowed(ip, true) http.Redirect(w, r, "/login?fout=1", http.StatusSeeOther) return } id := randHex(32) s.mu.Lock() for k, v := range s.sessions { if s.now().After(v.expires) { delete(s.sessions, k) } } s.sessions[id] = session{csrf: randHex(16), expires: s.now().Add(sessionTTL)} s.mu.Unlock() http.SetCookie(w, &http.Cookie{Name: sessionCookie, Value: id, Path: "/", HttpOnly: true, SameSite: http.SameSiteStrictMode, Secure: r.TLS != nil || r.Header.Get("X-Forwarded-Proto") == "https", MaxAge: int(sessionTTL / time.Second)}) http.Redirect(w, r, "/", http.StatusSeeOther) } func (s *Server) uiLogout(w http.ResponseWriter, r *http.Request) { if sess, ok := s.session(r); ok && r.PostFormValue("csrf") == sess.csrf { c, _ := r.Cookie(sessionCookie) s.mu.Lock() delete(s.sessions, c.Value) s.mu.Unlock() } http.SetCookie(w, &http.Cookie{Name: sessionCookie, Value: "", Path: "/", MaxAge: -1, HttpOnly: true}) http.Redirect(w, r, "/login", http.StatusSeeOther) } // pageData is wat de webinterface toont: precies de uitkomst van de // GET-acties uit Actions. type pageData struct { CSRF string Flash string FlashErr bool Status Status Config ConfigView Archives []archive.Archive Actions []Action Version string } func (s *Server) uiIndex(w http.ResponseWriter, r *http.Request) { sess, ok := s.session(r) if !ok { http.Redirect(w, r, "/login", http.StatusSeeOther) return } d := pageData{CSRF: sess.csrf, Status: s.Status(), Config: s.ConfigView(), Actions: s.Actions(), Version: Version} d.Archives, _ = s.archives.List() d.Flash, d.FlashErr = s.takeFlash(r) s.render(w, "index.html", d) } // uiAct voert een actie uit vanuit een formulier, via dezelfde code als de API. func (s *Server) uiAct(w http.ResponseWriter, r *http.Request) { sess, ok := s.session(r) if !ok { http.Redirect(w, r, "/login", http.StatusSeeOther) return } if err := r.ParseForm(); err != nil { http.Error(w, "formulier", 400) return } if subtle.ConstantTimeCompare([]byte(r.PostFormValue("csrf")), []byte(sess.csrf)) != 1 { http.Error(w, "CSRF-token klopt niet; laad de pagina opnieuw", http.StatusForbidden) return } a, ok := s.action(r.PathValue("name")) if !ok || a.Method == http.MethodGet { http.NotFound(w, r) return } in := Input{} for k, v := range r.PostForm { if k == "csrf" || k == "understood" || len(v) == 0 { continue } in[k] = v[0] } anchor := "#" + strings.SplitN(a.Name, ".", 2)[0] if a.Name == "rollback" && r.PostFormValue("understood") == "" { s.setFlash(r, "Vink aan dat je begrijpt dat een rollback niet ongedaan kan worden gemaakt.", true) http.Redirect(w, r, "/#archives", http.StatusSeeOther) return } if a.Name == "sync" { in["wait"] = "false" } code, out := a.Do(r.Context(), in) msg, isErr := describe(a, code, out) s.setFlash(r, msg, isErr) http.Redirect(w, r, "/"+anchor, http.StatusSeeOther) } func describe(a Action, code int, out any) (string, bool) { if code >= 400 { switch v := out.(type) { case *ConflictError: return fmt.Sprintf("%s (vorige: %s, %d archieven). Kies hieronder ‘oude backups wissen’ of ‘nieuwe BlueGit herstellen’ en koppel opnieuw.", v.Error, v.PreviousURL, v.Archives), true case map[string]string: return a.Title + " mislukt: " + v["error"], true } return fmt.Sprintf("%s mislukt (HTTP %d)", a.Title, code), true } switch a.Name { case "sync": return "Synchronisatie gestart.", false case "archive": if v, ok := out.(archive.Archive); ok { return "Archief gemaakt: " + v.Name, false } case "prune": if v, ok := out.(map[string]any); ok { return fmt.Sprintf("Opgeruimd: %d archieven.", len(v["removed"].([]string))), false } case "rollback": return "Rollback gestart. BlueGit herstart zodra de data er staat.", false case "config.update": if v, ok := out.(ConfigView); ok && v.Restart { return "Instellingen opgeslagen. Een deel geldt pas na een herstart.", false } return "Instellingen opgeslagen.", false } return a.Title + ": gelukt.", false } // UIPath is het formulieradres van een actie in de webinterface. func UIPath(a Action) string { return "/ui/act/" + url.PathEscape(a.Name) }