diff --git a/internal/web/web.go b/internal/web/web.go new file mode 100644 index 0000000..53d36dc --- /dev/null +++ b/internal/web/web.go @@ -0,0 +1,299 @@ +// Package web serves the public archive pages and the unsubscribe links. +package web + +import ( + "bytes" + "errors" + "html/template" + "log" + "net/http" + "net/url" + "strconv" + "strings" + "time" + + "codeberg.org/squidd/parsimony/internal/archive" + "codeberg.org/squidd/parsimony/internal/router" + "codeberg.org/squidd/parsimony/internal/store" +) + +const pageSize = 25 + +type server struct { + store *store.Store + router *router.Router + tmpl *template.Template +} + +// New returns the public web handler. +func New(s *store.Store, rt *router.Router) http.Handler { + srv := &server{store: s, router: rt, tmpl: template.Must(template.New("").Funcs(template.FuncMap{ + "hide": archive.Obfuscate, + "date": func(t time.Time) string { return t.UTC().Format("2006-01-02 15:04") }, + }).Parse(templates))} + + mux := http.NewServeMux() + mux.HandleFunc("GET /{$}", srv.index) + mux.HandleFunc("GET /archive/{address}", srv.archive) + mux.HandleFunc("GET /archive/{address}/{id}", srv.message) + mux.HandleFunc("GET /unsubscribe/{token}", srv.unsubscribePage) + mux.HandleFunc("POST /unsubscribe/{token}", srv.unsubscribe) + // Catch-all for GET so unknown paths get the HTML 404 page and other + // methods on known paths still answer 405. + mux.HandleFunc("GET /", func(w http.ResponseWriter, r *http.Request) { srv.notFound(w) }) + return secure(mux) +} + +// secure adds the headers every page needs. +func secure(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + h := w.Header() + h.Set("Content-Security-Policy", "default-src 'none'; style-src 'unsafe-inline'; form-action 'self'; base-uri 'none'; frame-ancestors 'none'") + h.Set("X-Content-Type-Options", "nosniff") + h.Set("Referrer-Policy", "no-referrer") + h.Set("Content-Type", "text/html; charset=utf-8") + if strings.HasPrefix(r.URL.Path, "/unsubscribe/") { + h.Set("Cache-Control", "no-store") // the URL carries a secret + } + next.ServeHTTP(w, r) + }) +} + +func (s *server) render(w http.ResponseWriter, status int, name string, data any) { + var buf bytes.Buffer + if err := s.tmpl.ExecuteTemplate(&buf, name, data); err != nil { + log.Printf("web: render %s: %v", name, err) + http.Error(w, "internal error", http.StatusInternalServerError) + return + } + w.WriteHeader(status) + w.Write(buf.Bytes()) +} + +func (s *server) notFound(w http.ResponseWriter) { s.render(w, http.StatusNotFound, "notfound", nil) } + +func (s *server) fail(w http.ResponseWriter, err error) { + log.Printf("web: %v", err) + http.Error(w, "internal error", http.StatusInternalServerError) +} + +// publicList resolves a list address and only returns lists with a public archive. +func (s *server) publicList(address string) (store.List, bool, error) { + l, err := s.store.FindList(address) + if errors.Is(err, store.ErrNotFound) || (err == nil && l.ArchivePolicy != store.ArchivePublic) { + return store.List{}, false, nil + } + return l, err == nil, err +} + +func (s *server) index(w http.ResponseWriter, r *http.Request) { + all, err := s.store.ListLists() + if err != nil { + s.fail(w, err) + return + } + var lists []store.List + for _, l := range all { + if l.ArchivePolicy == store.ArchivePublic { + lists = append(lists, l) + } + } + s.render(w, http.StatusOK, "index", lists) +} + +type archiveView struct { + List store.List + Query string + Messages []store.Message + Total int + Page int + PrevURL string + NextURL string + ResultText string +} + +func (s *server) archive(w http.ResponseWriter, r *http.Request) { + l, ok, err := s.publicList(r.PathValue("address")) + if err != nil { + s.fail(w, err) + return + } + if !ok { + s.notFound(w) + return + } + q := strings.TrimSpace(r.URL.Query().Get("q")) + page, _ := strconv.Atoi(r.URL.Query().Get("page")) + page = max(page, 1) + + fetch := func(offset int) ([]store.Message, int, error) { + if q != "" { + return s.store.SearchMessages(l.ID, q, pageSize, offset) + } + return s.store.ListMessages(l.ID, pageSize, offset) + } + ms, total, err := fetch((page - 1) * pageSize) + if err == nil { + if pages := (total + pageSize - 1) / pageSize; pages > 0 && page > pages { + page = pages + ms, total, err = fetch((page - 1) * pageSize) + } + } + if err != nil { + s.fail(w, err) + return + } + + v := archiveView{List: l, Query: q, Messages: ms, Total: total, Page: page} + link := func(p int) string { + vals := url.Values{} + if q != "" { + vals.Set("q", q) + } + if p > 1 { + vals.Set("page", strconv.Itoa(p)) + } + u := "/archive/" + l.Address() + if len(vals) > 0 { + u += "?" + vals.Encode() + } + return u + } + if page > 1 { + v.PrevURL = link(page - 1) + } + if page*pageSize < total { + v.NextURL = link(page + 1) + } + if q != "" { + v.ResultText = strconv.Itoa(total) + " results" + if total == 1 { + v.ResultText = "1 result" + } + } + s.render(w, http.StatusOK, "archive", v) +} + +type messageView struct { + List store.List + Message store.Message + Thread []store.Message +} + +func (s *server) message(w http.ResponseWriter, r *http.Request) { + l, ok, err := s.publicList(r.PathValue("address")) + if err != nil { + s.fail(w, err) + return + } + id, perr := strconv.ParseInt(r.PathValue("id"), 10, 64) + if !ok || perr != nil || id <= 0 { + s.notFound(w) + return + } + m, err := s.store.GetMessage(id) + if errors.Is(err, store.ErrNotFound) || (err == nil && m.ListID != l.ID) { + s.notFound(w) // also hides messages that belong to other lists + return + } + if err != nil { + s.fail(w, err) + return + } + thread, err := s.store.ThreadMessages(l.ID, m.ThreadID) + if err != nil { + s.fail(w, err) + return + } + s.render(w, http.StatusOK, "message", messageView{List: l, Message: m, Thread: thread}) +} + +func (s *server) unsubscribePage(w http.ResponseWriter, r *http.Request) { + l, err := s.router.CheckUnsubscribe(r.PathValue("token")) + switch { + case errors.Is(err, router.ErrBadToken): + s.notFound(w) + case errors.Is(err, router.ErrGone): + s.render(w, http.StatusOK, "unsubscribed", map[string]any{"Already": true}) + case err != nil: + s.fail(w, err) + default: + s.render(w, http.StatusOK, "unsubscribe", l) + } +} + +func (s *server) unsubscribe(w http.ResponseWriter, r *http.Request) { + err := s.router.Unsubscribe(r.PathValue("token")) + switch { + case errors.Is(err, router.ErrBadToken): + s.notFound(w) + case err != nil: + s.fail(w, err) + default: + s.render(w, http.StatusOK, "unsubscribed", map[string]any{"Already": false}) + } +} + +const templates = ` +{{define "head"}} +
+No public archives.
{{end}} +{{template "foot"}}{{end}} + +{{define "archive"}}{{template "head" .List.Title}} + +{{.List.Address}}
+ +{{if .Query}}{{.ResultText}} for "{{.Query}}"
{{end}} +{{if .Messages}}| Subject | From | Date |
|---|---|---|
| {{hide .Subject}} | {{hide .Sender}} | {{date .Date}} |
{{if .PrevURL}}← Newer{{end}} {{if .NextURL}}Older →{{end}}
+{{else}}{{if .Query}}No messages found.{{else}}No messages yet.{{end}}
{{end}} +{{template "foot"}}{{end}} + +{{define "message"}}{{template "head" (hide .Message.Subject)}} + +{{hide .Message.Sender}} · {{date .Message.Date}}
+{{hide .Message.Body}}
+{{if gt (len .Thread) 1}}Stop receiving messages from {{.Title}} ({{.Address}})?
+ +{{template "foot"}}{{end}} + +{{define "unsubscribed"}}{{template "head" "Unsubscribed"}} +{{if .Already}}This address no longer receives messages from the list.{{else}}You will not receive any more messages from the list.{{end}}
+{{template "foot"}}{{end}} + +{{define "notfound"}}{{template "head" "Not found"}} +", "Public", "A", "hello", 1_700_000_000, "") + + wantStatus(t, get(t, f.h, fmt.Sprintf("/archive/secret@example.org/%d", secretID)), 404) + // A public list URL must not reveal a message that belongs to another list. + wantStatus(t, get(t, f.h, fmt.Sprintf("/archive/dev@example.org/%d", secretID)), 404) + wantStatus(t, get(t, f.h, fmt.Sprintf("/archive/dev@example.org/%d", pubID)), 200) + for _, p := range []string{"/archive/dev@example.org/abc", "/archive/dev@example.org/0", "/archive/dev@example.org/999", "/archive/dev@example.org/-1"} { + wantStatus(t, get(t, f.h, p), 404) + } +} + +func TestPrivacyOfOriginalSender(t *testing.T) { + f := newFixture(t) + id := f.add(t, f.pub.ID, "<1@x>", "Contact bob@secret.example", "bob", "ping", 1_700_000_000, "") + rec := get(t, f.h, fmt.Sprintf("/archive/dev@example.org/%d", id)) + wantNoBody(t, rec, "bob@secret.example") + wantBody(t, rec, "bob@…") + rec = get(t, f.h, "/archive/dev@example.org") + wantNoBody(t, rec, "bob@secret.example") +} + +func TestSecurityHeaders(t *testing.T) { + f := newFixture(t) + for _, p := range []string{"/", "/archive/dev@example.org", "/nope"} { + h := get(t, f.h, p).Header() + if h.Get("X-Content-Type-Options") != "nosniff" || h.Get("Referrer-Policy") != "no-referrer" || + !strings.Contains(h.Get("Content-Security-Policy"), "default-src 'none'") || + !strings.HasPrefix(h.Get("Content-Type"), "text/html") { + t.Errorf("%s: headers %v", p, h) + } + } +} + +func TestOnlyGetOnArchive(t *testing.T) { + f := newFixture(t) + wantStatus(t, request(t, f.h, "POST", "/archive/dev@example.org"), 405) + wantStatus(t, request(t, f.h, "DELETE", "/"), 405) +} + +func TestUnsubscribeConfirmPageDoesNotUnsubscribe(t *testing.T) { + f := newFixture(t) + rec := get(t, f.h, "/unsubscribe/"+f.bobTok) + wantStatus(t, rec, 200) + wantBody(t, rec, `method="post"`, "Dev <b>talk</b>") + if ok, _ := f.s.IsMember(f.pub.ID, "bob@example.com"); !ok { + t.Fatal("a GET (link prefetch) must never unsubscribe") + } + h := rec.Header() + if h.Get("Cache-Control") != "no-store" || h.Get("Referrer-Policy") != "no-referrer" { + t.Errorf("token page headers: %v", h) + } +} + +func TestUnsubscribePost(t *testing.T) { + f := newFixture(t) + rec := request(t, f.h, "POST", "/unsubscribe/"+f.bobTok) + wantStatus(t, rec, 200) + wantBody(t, rec, "unsubscribed") + if ok, _ := f.s.IsMember(f.pub.ID, "bob@example.com"); ok { + t.Fatal("bob must be unsubscribed") + } + if ok, _ := f.s.IsMember(f.pub.ID, "alice@example.com"); !ok { + t.Fatal("alice must stay") + } + // Repeated one-click requests and a later visit are harmless. + wantStatus(t, request(t, f.h, "POST", "/unsubscribe/"+f.bobTok), 200) + rec = get(t, f.h, "/unsubscribe/"+f.bobTok) + wantStatus(t, rec, 200) + wantBody(t, rec, "already unsubscribed") +} + +func TestUnsubscribeRejectsBadTokens(t *testing.T) { + f := newFixture(t) + for _, tok := range []string{"x", "1-000000000000", "abc-def", f.bobTok + "0", "0-" + strings.Repeat("0", 12)} { + wantStatus(t, get(t, f.h, "/unsubscribe/"+tok), 404) + wantStatus(t, request(t, f.h, "POST", "/unsubscribe/"+tok), 404) + } + if n, _ := f.s.Members(f.pub.ID); len(n) != 2 { + t.Fatal("bad tokens must not remove anyone") + } +} + +func TestUnsubscribeOneClickBodyIsAccepted(t *testing.T) { + f := newFixture(t) + req := httptest.NewRequest("POST", "/unsubscribe/"+f.bobTok, strings.NewReader("List-Unsubscribe=One-Click")) + req.Header.Set("Content-Type", "application/x-www-form-urlencoded") + rec := httptest.NewRecorder() + f.h.ServeHTTP(rec, req) + wantStatus(t, rec, 200) + if ok, _ := f.s.IsMember(f.pub.ID, "bob@example.com"); ok { + t.Fatal("bob must be unsubscribed") + } +}