package app import ( "crypto/rand" "crypto/rsa" "crypto/x509" "encoding/base64" "encoding/pem" "errors" "io" "net" "net/http" "os" "path/filepath" "strings" "sync" "sync/atomic" "testing" "time" "github.com/emersion/go-msgauth/dkim" "github.com/emersion/go-smtp" "codeberg.org/squidd/parsimony/internal/config" "codeberg.org/squidd/parsimony/internal/store" ) // sink is a fake SMTP relay that records what it receives. type sink struct { mu sync.Mutex msgs []sunk } type sunk struct { from string to []string data string } func (s *sink) NewSession(*smtp.Conn) (smtp.Session, error) { return &sinkSession{s: s}, nil } type sinkSession struct { s *sink from string to []string } func (x *sinkSession) Reset() { x.from, x.to = "", nil } func (x *sinkSession) Logout() error { return nil } func (x *sinkSession) Mail(f string, _ *smtp.MailOptions) error { x.from = f return nil } func (x *sinkSession) Rcpt(t string, _ *smtp.RcptOptions) error { x.to = append(x.to, t) return nil } func (x *sinkSession) Data(r io.Reader) error { b, _ := io.ReadAll(r) x.s.mu.Lock() x.s.msgs = append(x.s.msgs, sunk{x.from, x.to, string(b)}) x.s.mu.Unlock() return nil } func (s *sink) count() int { s.mu.Lock() defer s.mu.Unlock() return len(s.msgs) } // waitCount waits until the relay holds n messages. func (s *sink) waitCount(t *testing.T, n int) { t.Helper() deadline := time.Now().Add(5 * time.Second) for s.count() < n { if time.Now().After(deadline) { t.Fatalf("relay has %d messages, want %d", s.count(), n) } time.Sleep(5 * time.Millisecond) } } func (s *sink) all() []sunk { s.mu.Lock() defer s.mu.Unlock() return append([]sunk(nil), s.msgs...) } func startSink(t *testing.T) (string, *sink) { t.Helper() sk := &sink{} srv := smtp.NewServer(sk) ln, err := net.Listen("tcp", "127.0.0.1:0") if err != nil { t.Fatal(err) } go srv.Serve(ln) t.Cleanup(func() { srv.Close() }) return ln.Addr().String(), sk } func testConfig(t *testing.T, relay string) config.Config { t.Helper() var c config.Config c.DB = t.TempDir() + "/p.db" c.LMTP.Network = "tcp" c.LMTP.Addr = "127.0.0.1:0" c.Relay.Addr = relay c.API.Listen = "127.0.0.1:0" c.Web.Listen = "127.0.0.1:0" return c } func call(t *testing.T, a *App, method, path, body, token string) int { t.Helper() req, _ := http.NewRequest(method, "http://"+a.APIAddr+path, strings.NewReader(body)) if token != "" { req.Header.Set("Authorization", "Bearer "+token) } resp, err := http.DefaultClient.Do(req) if err != nil { t.Fatal(err) } resp.Body.Close() return resp.StatusCode } func fetch(t *testing.T, method, url string) (int, string) { t.Helper() req, _ := http.NewRequest(method, url, nil) resp, err := http.DefaultClient.Do(req) if err != nil { t.Fatal(err) } defer resp.Body.Close() b, _ := io.ReadAll(resp.Body) return resp.StatusCode, string(b) } func lmtpSend(t *testing.T, addr, from, rcpt, msg string) error { t.Helper() conn, err := net.Dial("tcp", addr) if err != nil { t.Fatal(err) } c := smtp.NewClientLMTP(conn) defer c.Close() if err := c.Hello("localhost"); err != nil { t.Fatal(err) } if err := c.Mail(from, nil); err != nil { t.Fatal(err) } if err := c.Rcpt(rcpt, nil); err != nil { t.Fatal(err) } w, err := c.Data() if err != nil { t.Fatal(err) } w.Write([]byte(msg)) _, err = w.CloseWithLMTPResponse() return err } func TestEndToEnd(t *testing.T) { relayAddr, relay := startSink(t) a, err := Start(testConfig(t, relayAddr), "tok") if err != nil { t.Fatalf("start: %v", err) } t.Cleanup(func() { a.Close() }) if code := call(t, a, "GET", "/api/v1/health", "", ""); code != 200 { t.Fatalf("health = %d", code) } if code := call(t, a, "GET", "/api/v1/lists", "", ""); code != 401 { t.Fatalf("unauthenticated = %d", code) } if code := call(t, a, "POST", "/api/v1/lists", `{"name":"dev","domain":"example.org","title":"Dev"}`, "tok"); code != 201 { t.Fatalf("create list = %d", code) } for _, m := range []string{"alice@example.com", "bob@example.com"} { if code := call(t, a, "POST", "/api/v1/lists/1/members", `{"address":"`+m+`"}`, "tok"); code != 201 { t.Fatalf("add %s = %d", m, code) } } msg := "From: Alice \r\nSubject: hello\r\n\r\nbody\r\n" if err := lmtpSend(t, a.LMTPAddr, "alice@example.com", "dev@example.org", msg); err != nil { t.Fatalf("lmtp: %v", err) } relay.waitCount(t, 2) got := relay.all()[0] if !strings.Contains(got.data, "List-Id: Dev ") || !strings.HasPrefix(got.from, "dev+bounce-") { t.Fatalf("unexpected relayed mail: %+v", got) } if err := lmtpSend(t, a.LMTPAddr, "mallory@evil.com", "dev@example.org", msg); err == nil { t.Fatal("non-member must be rejected") } time.Sleep(100 * time.Millisecond) // give a wrongly queued message time to show up if relay.count() != 2 { t.Fatal("rejected mail must not be relayed") } } func TestStartWithoutTokenDisablesAPI(t *testing.T) { relayAddr, _ := startSink(t) a, err := Start(testConfig(t, relayAddr), "") if err != nil { t.Fatal(err) } t.Cleanup(func() { a.Close() }) if a.APIAddr != "" { t.Fatalf("API must be disabled, listening on %s", a.APIAddr) } if conn, err := net.DialTimeout("tcp", a.LMTPAddr, time.Second); err != nil { t.Fatalf("LMTP must still run: %v", err) } else { conn.Close() } } func TestStartFailsOnBadDatabase(t *testing.T) { c := testConfig(t, "127.0.0.1:1") c.DB = "/nonexistent-dir/x/p.db" if _, err := Start(c, ""); err == nil { t.Fatal("want error") } } func TestStartFailsWhenPortIsBusy(t *testing.T) { ln, _ := net.Listen("tcp", "127.0.0.1:0") defer ln.Close() c := testConfig(t, "127.0.0.1:1") c.LMTP.Addr = ln.Addr().String() if _, err := Start(c, ""); err == nil { t.Fatal("want error") } } func TestCloseIsIdempotentAndStopsListeners(t *testing.T) { relayAddr, _ := startSink(t) a, _ := Start(testConfig(t, relayAddr), "tok") addr := a.LMTPAddr a.Close() a.Close() if c, err := net.DialTimeout("tcp", addr, 200*time.Millisecond); err == nil { c.Close() t.Fatal("LMTP still accepting after Close") } } func TestArchiveAndUnsubscribeEndToEnd(t *testing.T) { relayAddr, relay := startSink(t) cfg := testConfig(t, relayAddr) cfg.BaseURL = "http://placeholder.invalid" a, err := Start(cfg, "tok") if err != nil { t.Fatal(err) } t.Cleanup(func() { a.Close() }) if a.WebAddr == "" { t.Fatal("web must be listening") } call(t, a, "POST", "/api/v1/lists", `{"name":"dev","domain":"example.org","title":"Dev"}`, "tok") for _, m := range []string{"alice@example.com", "bob@example.com"} { call(t, a, "POST", "/api/v1/lists/1/members", `{"address":"`+m+`"}`, "tok") } web := "http://" + a.WebAddr // Private by default: stored but not on the web. msg := "From: Alice \r\nSubject: Quarterly plan\r\nMessage-ID: \r\n\r\nmail me at alice@example.com\r\n" if err := lmtpSend(t, a.LMTPAddr, "alice@example.com", "dev@example.org", msg); err != nil { t.Fatal(err) } if code, _ := fetch(t, "GET", web+"/archive/dev@example.org"); code != 404 { t.Fatalf("private archive must be 404, got %d", code) } if code := call(t, a, "GET", "/api/v1/lists/1/archive?q=quarterly", "", "tok"); code != 200 { t.Fatalf("api archive = %d", code) } // Make it public. if code := call(t, a, "PATCH", "/api/v1/lists/1", `{"archive_policy":"public"}`, "tok"); code != 200 { t.Fatalf("patch = %d", code) } code, body := fetch(t, "GET", web+"/archive/dev@example.org?q=quarterly") if code != 200 || !strings.Contains(body, "Quarterly plan") { t.Fatalf("public archive: %d %.200s", code, body) } code, body = fetch(t, "GET", web+"/archive/dev@example.org/1") if code != 200 || !strings.Contains(body, "alice@…") || strings.Contains(body, "alice@example.com") { t.Fatalf("message page must hide addresses: %d %.300s", code, body) } // The relayed copy carries a working one-click link for that recipient. relay.waitCount(t, 2) var link string for _, m := range relay.all() { if len(m.to) == 1 && m.to[0] == "bob@example.com" { i := strings.Index(m.data, "List-Unsubscribe: ")] } } if link == "" { t.Fatal("bob got no copy") } if code, _ := fetch(t, "GET", web+link); code != 200 { t.Fatalf("confirm page = %d", code) } if code, _ := fetch(t, "POST", web+link); code != 200 { t.Fatalf("one-click = %d", code) } before := relay.count() if err := lmtpSend(t, a.LMTPAddr, "alice@example.com", "dev@example.org", "From: Alice \r\nSubject: Second\r\nMessage-ID: \r\n\r\nhi\r\n"); err != nil { t.Fatal(err) } relay.waitCount(t, before+1) time.Sleep(100 * time.Millisecond) if got := relay.count() - before; got != 1 { t.Fatalf("after bob left only alice should get a copy, got %d", got) } } func TestWebDisabledWhenListenIsEmpty(t *testing.T) { relayAddr, _ := startSink(t) cfg := testConfig(t, relayAddr) cfg.Web.Listen = "" a, err := Start(cfg, "tok") if err != nil { t.Fatal(err) } t.Cleanup(func() { a.Close() }) if a.WebAddr != "" { t.Fatalf("web must be off, listening on %s", a.WebAddr) } } func TestCloseDropsOpenConnections(t *testing.T) { relayAddr, _ := startSink(t) a, err := Start(testConfig(t, relayAddr), "tok") if err != nil { t.Fatal(err) } conns := map[string]net.Conn{} for name, addr := range map[string]string{"web": a.WebAddr, "api": a.APIAddr, "lmtp": a.LMTPAddr} { c, err := net.Dial("tcp", addr) if err != nil { t.Fatal(err) } defer c.Close() conns[name] = c } time.Sleep(100 * time.Millisecond) // let the servers accept a.Close() for name, c := range conns { c.SetReadDeadline(time.Now().Add(2 * time.Second)) buf := make([]byte, 512) for { if _, err := c.Read(buf); err != nil { if ne, ok := err.(net.Error); ok && ne.Timeout() { t.Errorf("%s: connection still open after Close", name) } break } } } } func TestAdminUIAndAPIShareTheListener(t *testing.T) { relayAddr, _ := startSink(t) a, err := Start(testConfig(t, relayAddr), "tok") if err != nil { t.Fatal(err) } t.Cleanup(func() { a.Close() }) base := "http://" + a.APIAddr // The API is not shadowed by the UI. if code, body := fetch(t, "GET", base+"/api/v1/health"); code != 200 || !strings.Contains(body, `"status"`) { t.Fatalf("health: %d %q", code, body) } if code, _ := fetch(t, "GET", base+"/api/v1/lists"); code != 401 { t.Fatalf("api must still require a token, got %d", code) } if code, body := fetch(t, "GET", base+"/api/nope"); code == 200 || strings.Contains(strings.ToLower(body), "") { t.Fatalf("%s: not the UI: %q", p, body) } case 503: if !strings.Contains(body, "make admin") { t.Fatalf("%s: 503 without a hint: %q", p, body) } default: t.Fatalf("%s: status %d", p, code) } } } // deadAddr returns an address nothing listens on. func deadAddr(t *testing.T) string { t.Helper() ln, err := net.Listen("tcp", "127.0.0.1:0") if err != nil { t.Fatal(err) } addr := ln.Addr().String() ln.Close() return addr } func TestQueuedMailSurvivesARestartAndIsRetriedWhenTheRelayReturns(t *testing.T) { var skew atomic.Int64 nowFunc = func() time.Time { return time.Now().Add(time.Duration(skew.Load())) } t.Cleanup(func() { nowFunc = time.Now }) // 1. The relay is down: the post is still accepted and stays queued. cfg := testConfig(t, deadAddr(t)) a, err := Start(cfg, "tok") if err != nil { t.Fatal(err) } call(t, a, "POST", "/api/v1/lists", `{"name":"dev","domain":"example.org","title":"Dev"}`, "tok") for _, m := range []string{"alice@example.com", "bob@example.com"} { call(t, a, "POST", "/api/v1/lists/1/members", `{"address":"`+m+`"}`, "tok") } msg := "From: Alice \r\nSubject: queued\r\nMessage-ID: \r\n\r\nbody\r\n" if err := lmtpSend(t, a.LMTPAddr, "alice@example.com", "dev@example.org", msg); err != nil { t.Fatalf("a post must be accepted while the relay is down: %v", err) } peek, err := store.Open(cfg.DB) if err != nil { t.Fatal(err) } defer peek.Close() deadline := time.Now().Add(5 * time.Second) for { st, _ := peek.OutboxStats() if st.Pending == 2 && st.Retrying == 2 { break } if time.Now().After(deadline) { t.Fatalf("queue after the first attempts: %+v", st) } time.Sleep(10 * time.Millisecond) } // 2. Restart with a working relay, after the backoff has passed. a.Close() relayAddr, relay := startSink(t) cfg.Relay.Addr = relayAddr skew.Store(int64(10 * time.Minute)) b, err := Start(cfg, "tok") if err != nil { t.Fatal(err) } t.Cleanup(func() { b.Close() }) relay.waitCount(t, 2) got := relay.all() if !strings.Contains(got[0].data, "List-Id: Dev ") || !strings.Contains(got[0].data, "Subject: queued") { t.Fatalf("delivered mail: %q", got[0].data) } deadline = time.Now().Add(5 * time.Second) for { st, _ := peek.OutboxStats() if st.Pending == 0 { break } if time.Now().After(deadline) { t.Fatalf("delivered mail must leave the queue: %+v", st) } time.Sleep(10 * time.Millisecond) } } func TestCloseInterruptsASlowSendWithoutLosingIt(t *testing.T) { // A relay that accepts the connection and never answers. ln, _ := net.Listen("tcp", "127.0.0.1:0") t.Cleanup(func() { ln.Close() }) go func() { for { c, err := ln.Accept() if err != nil { return } defer c.Close() } }() cfg := testConfig(t, ln.Addr().String()) a, err := Start(cfg, "tok") if err != nil { t.Fatal(err) } call(t, a, "POST", "/api/v1/lists", `{"name":"dev","domain":"example.org"}`, "tok") call(t, a, "POST", "/api/v1/lists/1/members", `{"address":"alice@example.com"}`, "tok") msg := "From: Alice \r\nSubject: slow\r\nMessage-ID: \r\n\r\nbody\r\n" if err := lmtpSend(t, a.LMTPAddr, "alice@example.com", "dev@example.org", msg); err != nil { t.Fatal(err) } time.Sleep(200 * time.Millisecond) // the worker is now stuck talking to the silent relay closed := make(chan struct{}) go func() { a.Close(); close(closed) }() select { case <-closed: case <-time.After(5 * time.Second): t.Fatal("Close must not wait for a hung relay") } peek, err := store.Open(cfg.DB) if err != nil { t.Fatal(err) } defer peek.Close() if st, _ := peek.OutboxStats(); st.Pending != 1 { t.Fatalf("the interrupted delivery must stay queued: %+v", st) } } // dkimKey writes a fresh RSA key as PKCS#1 PEM and returns the file and the public key. func dkimKey(t *testing.T) (string, *rsa.PublicKey) { t.Helper() k, err := rsa.GenerateKey(rand.Reader, 2048) if err != nil { t.Fatal(err) } path := filepath.Join(t.TempDir(), "dkim.pem") if err := os.WriteFile(path, pem.EncodeToMemory(&pem.Block{Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(k)}), 0o600); err != nil { t.Fatal(err) } return path, &k.PublicKey } func verifyDKIM(t *testing.T, raw string, selector, domain string, pub *rsa.PublicKey) []*dkim.Verification { t.Helper() der, _ := x509.MarshalPKIXPublicKey(pub) vs, err := dkim.VerifyWithOptions(strings.NewReader(raw), &dkim.VerifyOptions{ LookupTXT: func(name string) ([]string, error) { if name == selector+"._domainkey."+domain { return []string{"v=DKIM1; k=rsa; p=" + base64.StdEncoding.EncodeToString(der)}, nil } return nil, errors.New("no record " + name) }, }) if err != nil { t.Fatalf("verify: %v", err) } return vs } func TestOutgoingMailIsSignedWhenAKeyIsConfigured(t *testing.T) { relayAddr, relay := startSink(t) keyFile, pub := dkimKey(t) cfg := testConfig(t, relayAddr) cfg.DKIM = []config.DKIMKey{{Domain: "example.org", Selector: "mail", KeyFile: keyFile}} a, err := Start(cfg, "tok") if err != nil { t.Fatal(err) } t.Cleanup(func() { a.Close() }) call(t, a, "POST", "/api/v1/lists", `{"name":"dev","domain":"example.org","title":"Dev"}`, "tok") call(t, a, "POST", "/api/v1/lists/1/members", `{"address":"alice@example.com"}`, "tok") // A post. msg := "From: Alice \r\nSubject: signed post\r\nMessage-ID: \r\n\r\nbody\r\n" if err := lmtpSend(t, a.LMTPAddr, "alice@example.com", "dev@example.org", msg); err != nil { t.Fatal(err) } // A confirmation mail (system mail) from the same list domain. if err := lmtpSend(t, a.LMTPAddr, "carol@x.com", "dev+join@example.org", ""); err != nil { t.Fatal(err) } relay.waitCount(t, 2) signed := 0 for _, m := range relay.all() { vs := verifyDKIM(t, m.data, "mail", "example.org", pub) if len(vs) != 1 || vs[0].Err != nil || vs[0].Domain != "example.org" { t.Fatalf("every outgoing message is signed with the list domain: %+v\n%.300s", vs, m.data) } signed++ } if signed != 2 { t.Fatalf("signed %d", signed) } } func TestMailIsUnsignedWithoutKeysAndForOtherDomains(t *testing.T) { relayAddr, relay := startSink(t) keyFile, _ := dkimKey(t) cfg := testConfig(t, relayAddr) cfg.DKIM = []config.DKIMKey{{Domain: "another.test", Selector: "mail", KeyFile: keyFile}} a, err := Start(cfg, "tok") if err != nil { t.Fatal(err) } t.Cleanup(func() { a.Close() }) call(t, a, "POST", "/api/v1/lists", `{"name":"dev","domain":"example.org"}`, "tok") call(t, a, "POST", "/api/v1/lists/1/members", `{"address":"alice@example.com"}`, "tok") msg := "From: Alice \r\nSubject: x\r\nMessage-ID: \r\n\r\nbody\r\n" if err := lmtpSend(t, a.LMTPAddr, "alice@example.com", "dev@example.org", msg); err != nil { t.Fatal(err) } relay.waitCount(t, 1) if strings.Contains(relay.all()[0].data, "DKIM-Signature") { t.Fatal("a list on a domain without a key is sent unsigned") } } func TestStartFailsOnAnUnusableDKIMKey(t *testing.T) { relayAddr, _ := startSink(t) bad := filepath.Join(t.TempDir(), "bad.pem") os.WriteFile(bad, []byte("not a key"), 0o600) for name, keyFile := range map[string]string{"missing file": "/nonexistent/dkim.pem", "garbage": bad} { cfg := testConfig(t, relayAddr) cfg.DKIM = []config.DKIMKey{{Domain: "example.org", Selector: "mail", KeyFile: keyFile}} a, err := Start(cfg, "tok") if err == nil { a.Close() t.Fatalf("%s: a broken key must stop the daemon at startup, not later at send time", name) } if !strings.Contains(err.Error(), "dkim") || !strings.Contains(err.Error(), "example.org") { t.Errorf("%s: the error names the key: %v", name, err) } } }