Behind a reverse proxy every visitor shared the proxy's address, so the whole site got 10 signups an hour and one person could block everyone. Over IPv6 each address of a /64 was a fresh key, so the limit did not bind and the map grew by one entry per address. - web.trusted_proxies (addresses or CIDR ranges, default empty) is validated at load and passed to the web handler. X-Forwarded-For is read only when the TCP peer is a trusted proxy; the client is then the right-most entry that is not itself a trusted proxy. An empty or malformed header falls back to the peer. With no trusted proxy the behaviour is unchanged: the header is ignored. - IPv6 clients are keyed by their /64, IPv4 clients by address. - The limiter remembers at most 100000 clients. When full it sweeps expired entries first and otherwise answers 429 to new clients until the oldest window ends, instead of growing.
457 lines
15 KiB
Go
457 lines
15 KiB
Go
// 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"
|
|
|
|
"codeberg.org/squidd/parsimony/assets"
|
|
"codeberg.org/squidd/parsimony/internal/archive"
|
|
"codeberg.org/squidd/parsimony/internal/router"
|
|
"codeberg.org/squidd/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.
|
|
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 {
|
|
return "", false
|
|
}
|
|
return s, 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"}}<!doctype html>
|
|
<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1">
|
|
<title>{{.}}</title>
|
|
<link rel="icon" type="image/svg+xml" href="{{favicon}}">
|
|
<style>
|
|
body{font:16px/1.5 system-ui,sans-serif;max-width:50rem;margin:2rem auto;padding:0 1rem;color:#222}
|
|
a{color:#0b5cad}
|
|
h1{font-size:1.5rem}
|
|
table{border-collapse:collapse;width:100%}
|
|
td,th{text-align:left;padding:.35rem .5rem;border-bottom:1px solid #ddd;vertical-align:top}
|
|
pre{white-space:pre-wrap;word-wrap:break-word;background:#f6f6f6;padding:1rem;border-radius:4px}
|
|
.muted{color:#666;font-size:.9rem}
|
|
.cur{font-weight:bold}
|
|
input[type=search]{padding:.35rem;width:16rem}
|
|
button{padding:.5rem 1rem;font-size:1rem}
|
|
nav a{margin-right:1rem}
|
|
.error{color:#b00020}
|
|
.hp{position:absolute;left:-10000px;width:1px;height:1px;overflow:hidden}
|
|
input[type=email]{padding:.35rem;width:20rem;max-width:100%}
|
|
.brand{display:inline-block;margin-bottom:1rem}
|
|
.brand svg{width:2rem;height:2rem;display:block}
|
|
</style></head><body>
|
|
<a class="brand" href="/" aria-label="All archives">{{mark}}</a>{{end}}
|
|
{{define "foot"}}</body></html>{{end}}
|
|
|
|
{{define "index"}}{{template "head" "Mailing list archives"}}
|
|
<h1>Mailing list archives</h1>
|
|
{{if .}}<ul>{{range .}}<li><a href="/archive/{{.Address}}">{{.Address}}</a> <span class="muted">{{.Title}}</span></li>{{end}}</ul>
|
|
{{else}}<p>No public archives.</p>{{end}}
|
|
{{template "foot"}}{{end}}
|
|
|
|
{{define "archive"}}{{template "head" .List.Title}}
|
|
<nav><a href="/">All lists</a>{{if .CanSubscribe}}<a href="/subscribe/{{.List.Address}}">Subscribe</a>{{end}}</nav>
|
|
<h1>{{.List.Title}}</h1>
|
|
<p class="muted">{{.List.Address}}</p>
|
|
<form method="get" action="/archive/{{.List.Address}}"><input type="search" name="q" value="{{.Query}}" placeholder="Search"> <button>Search</button></form>
|
|
{{if .Query}}<p class="muted">{{.ResultText}} for "{{.Query}}"</p>{{end}}
|
|
{{if .Messages}}<table><tr><th>Subject</th><th>From</th><th>Date</th></tr>
|
|
{{range .Messages}}<tr><td><a href="/archive/{{$.List.Address}}/{{.ID}}">{{hide .Subject}}</a></td><td>{{hide .Sender}}</td><td class="muted">{{date .Date}}</td></tr>
|
|
{{end}}</table>
|
|
<p>{{if .PrevURL}}<a href="{{.PrevURL}}">← Newer</a>{{end}} {{if .NextURL}}<a href="{{.NextURL}}">Older →</a>{{end}}</p>
|
|
{{else}}<p>{{if .Query}}No messages found.{{else}}No messages yet.{{end}}</p>{{end}}
|
|
{{template "foot"}}{{end}}
|
|
|
|
{{define "message"}}{{template "head" (hide .Message.Subject)}}
|
|
<nav><a href="/">All lists</a><a href="/archive/{{.List.Address}}">{{.List.Title}}</a></nav>
|
|
<h1>{{hide .Message.Subject}}</h1>
|
|
<p class="muted">{{hide .Message.Sender}} · {{date .Message.Date}}</p>
|
|
<pre>{{hide .Message.Body}}</pre>
|
|
{{if gt (len .Thread) 1}}<h2>Thread</h2><ul>
|
|
{{range .Thread}}<li>{{if eq .ID $.Message.ID}}<span class="cur">{{hide .Subject}}</span>{{else}}<a href="/archive/{{$.List.Address}}/{{.ID}}">{{hide .Subject}}</a>{{end}}
|
|
<span class="muted">{{hide .Sender}}, {{date .Date}}</span></li>{{end}}</ul>{{end}}
|
|
{{template "foot"}}{{end}}
|
|
|
|
{{define "subscribe"}}{{template "head" (print "Subscribe to " .List.Title)}}
|
|
<nav><a href="/">All lists</a><a href="/archive/{{.List.Address}}">{{.List.Title}}</a></nav>
|
|
<h1>Subscribe to {{.List.Title}}</h1>
|
|
<p class="muted">{{.List.Address}}</p>
|
|
{{if .Error}}<p class="error" role="alert">{{.Error}}</p>{{end}}
|
|
<form method="post" action="/subscribe/{{.List.Address}}">
|
|
<p><label>Email address<br><input type="email" name="email" value="{{.Email}}" required maxlength="254" autocomplete="email"></label></p>
|
|
<div class="hp" aria-hidden="true"><label>Leave this empty<input type="text" name="website" tabindex="-1" autocomplete="off"></label></div>
|
|
<button>Subscribe</button>
|
|
</form>
|
|
<p class="muted">We send one message to confirm the address. Nothing happens until you reply to it.</p>
|
|
{{template "foot"}}{{end}}
|
|
|
|
{{define "subscribed"}}{{template "head" "Check your email"}}
|
|
<h1>Check your email</h1>
|
|
<p>If this address can subscribe, a confirmation message is on its way. Open it and reply to confirm.</p>
|
|
{{template "foot"}}{{end}}
|
|
|
|
{{define "toomany"}}{{template "head" "Too many requests"}}
|
|
<h1>Too many requests</h1><p>Please try again later.</p>
|
|
{{template "foot"}}{{end}}
|
|
|
|
{{define "unsubscribe"}}{{template "head" "Unsubscribe"}}
|
|
<h1>Unsubscribe</h1>
|
|
<p>Stop receiving messages from <strong>{{.Title}}</strong> ({{.Address}})?</p>
|
|
<form method="post"><button>Unsubscribe</button></form>
|
|
{{template "foot"}}{{end}}
|
|
|
|
{{define "unsubscribed"}}{{template "head" "Unsubscribed"}}
|
|
<h1>{{if .Already}}You are already unsubscribed{{else}}You are unsubscribed{{end}}</h1>
|
|
<p>{{if .Already}}This address no longer receives messages from the list.{{else}}You will not receive any more messages from the list.{{end}}</p>
|
|
{{template "foot"}}{{end}}
|
|
|
|
{{define "notfound"}}{{template "head" "Not found"}}
|
|
<h1>Not found</h1><p><a href="/">Back to the archives</a></p>
|
|
{{template "foot"}}{{end}}
|
|
`
|