// Package web serves the public archive pages and the unsubscribe links. package web import ( "bytes" "encoding/base64" "errors" "html/template" "log" "net" "net/http" "net/mail" "net/url" "strconv" "strings" "time" "unicode" "git.kmalloc.org/squid/parsimony/assets" "git.kmalloc.org/squid/parsimony/internal/archive" "git.kmalloc.org/squid/parsimony/internal/router" "git.kmalloc.org/squid/parsimony/internal/store" ) const pageSize = 25 // faviconURL is the logo as a data: URI, the only kind of image the CSP allows. var faviconURL = "data:image/svg+xml;base64," + base64.StdEncoding.EncodeToString([]byte(assets.Mark)) type server struct { store *store.Store router *router.Router tmpl *template.Template limit *subscribeLimiter // trusted are the reverse proxies whose X-Forwarded-For is believed. trusted []*net.IPNet } // New returns the public web handler. trustedProxies are the reverse proxies allowed to name the // client in X-Forwarded-For (none: the TCP peer is the client). func New(s *store.Store, rt *router.Router, trustedProxies []*net.IPNet) http.Handler { return newHandler(s, rt, time.Now, trustedProxies) } // newHandler is New with an injectable clock, for the tests. func newHandler(s *store.Store, rt *router.Router, now func() time.Time, trusted []*net.IPNet) http.Handler { srv := &server{store: s, router: rt, limit: newSubscribeLimiter(now), trusted: trusted, tmpl: template.Must(template.New("").Funcs(template.FuncMap{ "hide": archive.Obfuscate, // The logo is a trusted static asset: inline, so the strict CSP needs no image source for it. "mark": func() template.HTML { return template.HTML(assets.Mark) }, "favicon": func() template.URL { return template.URL(faviconURL) }, "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 /subscribe/{address}", srv.subscribeForm) mux.HandleFunc("POST /subscribe/{address}", srv.subscribe) 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'; img-src data:; 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 } if strings.HasPrefix(r.URL.Path, "/subscribe/") { h.Set("Cache-Control", "no-store") // a form with an address typed into it } 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 // CanSubscribe is true when /subscribe/{address} serves this list. CanSubscribe bool } 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, CanSubscribe: l.JoinPolicy == store.JoinOpen} 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}) } // subscribableList resolves a list for the subscribe form: it must have a public archive and accept // self-service subscriptions. Anything else is reported as missing, so a private or closed list // cannot be told from one that does not exist. func (s *server) subscribableList(address string) (store.List, bool, error) { l, ok, err := s.publicList(address) if err != nil || !ok || l.JoinPolicy != store.JoinOpen { return store.List{}, false, err } return l, true, nil } type subscribeView struct { List store.List Email string Error string } func (s *server) subscribeForm(w http.ResponseWriter, r *http.Request) { l, ok, err := s.subscribableList(r.PathValue("address")) switch { case err != nil: s.fail(w, err) case !ok: s.notFound(w) default: s.render(w, http.StatusOK, "subscribe", subscribeView{List: l}) } } // maxSubscribeBody is plenty for an email address and a honeypot field. const maxSubscribeBody = 4 << 10 func (s *server) subscribe(w http.ResponseWriter, r *http.Request) { if wait, ok := s.limit.allow(clientKey(r, s.trusted)); !ok { w.Header().Set("Retry-After", strconv.Itoa(int((wait+time.Second-1)/time.Second))) s.render(w, http.StatusTooManyRequests, "toomany", nil) return } l, ok, err := s.subscribableList(r.PathValue("address")) if err != nil { s.fail(w, err) return } if !ok { s.notFound(w) return } r.Body = http.MaxBytesReader(w, r.Body, maxSubscribeBody) if err := r.ParseForm(); err != nil { var tooBig *http.MaxBytesError if errors.As(err, &tooBig) { http.Error(w, "request too large", http.StatusRequestEntityTooLarge) return } } // A bot that fills every field gets the page a person gets, and nothing happens. if r.PostForm.Get("website") != "" { s.render(w, http.StatusOK, "subscribed", nil) return } typed := r.PostForm.Get("email") addr, ok := plainAddress(typed) if !ok { s.render(w, http.StatusBadRequest, "subscribe", subscribeView{List: l, Email: printable(typed), Error: "Enter a valid email address."}) return } if err := s.router.RequestJoin(l.Address(), addr); err != nil { s.fail(w, err) return } s.render(w, http.StatusOK, "subscribed", nil) } // printable drops control characters, so what was typed can be shown back safely. func printable(s string) string { return strings.Map(func(r rune) rune { if unicode.IsControl(r) { return -1 } return r }, s) } // plainAddress accepts one bare ASCII address of at most 254 characters: no display name, no angle // brackets, no list, no quoting, no control characters, and a public domain (see publicDomain). func plainAddress(s string) (string, bool) { s = strings.TrimSpace(s) if s == "" || len(s) > 254 { return "", false } for _, c := range []byte(s) { if c <= ' ' || c >= 0x7f { return "", false } } a, err := mail.ParseAddress(s) if err != nil || a.Name != "" || a.Address != s || !publicDomain(s[strings.LastIndexByte(s, '@')+1:]) { return "", false } return s, true } // publicDomain accepts a domain name that can be on the Internet: dotted labels of letters, digits // and hyphens, not an IP address, and not one of the names reserved for local use. A domain literal // ([127.0.0.1]), a bare host (localhost) or a .local name would make the daemon mail itself or its // network. func publicDomain(d string) bool { d = strings.ToLower(d) if !strings.Contains(d, ".") { return false } for _, label := range strings.Split(d, ".") { if label == "" || strings.ContainsFunc(label, func(r rune) bool { return !(r >= 'a' && r <= 'z' || r >= '0' && r <= '9' || r == '-') }) { return false } } // No top-level domain is all digits: such a name is an IP address (a@127.0.0.1). if strings.Trim(d[strings.LastIndexByte(d, '.')+1:], "0123456789") == "" { return false } for _, local := range []string{".localhost", ".local", ".internal", ".invalid"} { if strings.HasSuffix(d, local) { return false } } return true } 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"}} {{.}} {{mark}}{{end}} {{define "foot"}}{{end}} {{define "index"}}{{template "head" "Mailing list archives"}}

Mailing list archives

{{if .}} {{else}}

No public archives.

{{end}} {{template "foot"}}{{end}} {{define "archive"}}{{template "head" .List.Title}}

{{.List.Title}}

{{.List.Address}}

{{if .Query}}

{{.ResultText}} for "{{.Query}}"

{{end}} {{if .Messages}} {{range .Messages}} {{end}}
SubjectFromDate
{{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.Subject}}

{{hide .Message.Sender}} · {{date .Message.Date}}

{{hide .Message.Body}}
{{if gt (len .Thread) 1}}

Thread

{{end}} {{template "foot"}}{{end}} {{define "subscribe"}}{{template "head" (print "Subscribe to " .List.Title)}}

Subscribe to {{.List.Title}}

{{.List.Address}}

{{if .Error}}{{end}}

We send one message to confirm the address. Nothing happens until you reply to it.

{{template "foot"}}{{end}} {{define "subscribed"}}{{template "head" "Check your email"}}

Check your email

If this address can subscribe, a confirmation message is on its way. Open it and reply to confirm.

{{template "foot"}}{{end}} {{define "toomany"}}{{template "head" "Too many requests"}}

Too many requests

Please try again later.

{{template "foot"}}{{end}} {{define "unsubscribe"}}{{template "head" "Unsubscribe"}}

Unsubscribe

Stop receiving messages from {{.Title}} ({{.Address}})?

{{template "foot"}}{{end}} {{define "unsubscribed"}}{{template "head" "Unsubscribed"}}

{{if .Already}}You are already unsubscribed{{else}}You are unsubscribed{{end}}

{{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"}}

Not found

Back to the archives

{{template "foot"}}{{end}} `