From d4f706523f78558ffddaa2c0065acb338030de14 Mon Sep 17 00:00:00 2001 From: tgiachi Date: Tue, 10 Nov 2026 12:37:00 +0100 Subject: [PATCH] feat(router): the publishers post policy refuses non-publishers - Route on a publishers list lets through a member flagged publisher, after the unchanged discard and loop checks, and applies the usual From header check - anyone else gets the new ErrNotPublisher: never held, archived or queued - ingest answers ErrNotPublisher with 550 5.7.1 only the publishers of this list may post - tests: publisher ok, plain member and stranger refused, disabled publisher posts, identity mismatch held and released, discard rules first, other policies unchanged --- internal/ingest/ingest.go | 2 + internal/ingest/publisher_test.go | 31 +++++++ internal/router/publisher_test.go | 143 ++++++++++++++++++++++++++++++ internal/router/router.go | 25 ++++-- 4 files changed, 195 insertions(+), 6 deletions(-) create mode 100644 internal/ingest/publisher_test.go create mode 100644 internal/router/publisher_test.go diff --git a/internal/ingest/ingest.go b/internal/ingest/ingest.go index 42a0e20..953300f 100644 --- a/internal/ingest/ingest.go +++ b/internal/ingest/ingest.go @@ -96,6 +96,8 @@ func (s *session) status(rcpt string, err error) error { return &smtp.SMTPError{Code: 552, EnhancedCode: smtp.EnhancedCode{5, 3, 4}, Message: "message too large for this moderated list"} case errors.Is(err, router.ErrNotMember): return &smtp.SMTPError{Code: 550, EnhancedCode: smtp.EnhancedCode{5, 7, 1}, Message: "only list members may post"} + case errors.Is(err, router.ErrNotPublisher): + return &smtp.SMTPError{Code: 550, EnhancedCode: smtp.EnhancedCode{5, 7, 1}, Message: "only the publishers of this list may post"} case errors.Is(err, router.ErrBadToken): return &smtp.SMTPError{Code: 550, EnhancedCode: smtp.EnhancedCode{5, 7, 1}, Message: "invalid or expired token"} case errors.Is(err, router.ErrJoinClosed): diff --git a/internal/ingest/publisher_test.go b/internal/ingest/publisher_test.go new file mode 100644 index 0000000..aa9aff0 --- /dev/null +++ b/internal/ingest/publisher_test.go @@ -0,0 +1,31 @@ +package ingest + +import ( + "errors" + "testing" + + "github.com/emersion/go-smtp" + + "codeberg.org/squidd/parsimony/internal/store" +) + +func TestANonPublisherIsRefusedPermanentlyByANewsletter(t *testing.T) { + st := newStack(t, nil) + l, _ := st.store.FindList("dev@example.org") + st.store.SetPolicies(l.ID, store.PostPublishers, store.JoinOpen, store.ArchivePrivate) + res := deliver(t, st.addr, "alice@example.com", []string{"dev@example.org"}) + var se *smtp.SMTPError + if !errors.As(res["dev@example.org"], &se) || se.Code != 550 || + se.EnhancedCode != (smtp.EnhancedCode{5, 7, 1}) || se.Message != "only the publishers of this list may post" { + t.Fatalf("want 550 5.7.1, got %v", res["dev@example.org"]) + } + if st.queued(t) != 0 { + t.Fatal("nothing may be queued") + } + + st.store.SetPublisher(l.ID, "alice@example.com", true) + if res := deliver(t, st.addr, "alice@example.com", []string{"dev@example.org"}); res["dev@example.org"] != nil { + t.Fatalf("a publisher posts: %v", res["dev@example.org"]) + } + st.sent(t, 2) +} diff --git a/internal/router/publisher_test.go b/internal/router/publisher_test.go new file mode 100644 index 0000000..c80f3db --- /dev/null +++ b/internal/router/publisher_test.go @@ -0,0 +1,143 @@ +package router + +import ( + "errors" + "strings" + "testing" + + "codeberg.org/squidd/parsimony/internal/store" +) + +// newsletterEnv is the test list with the publishers post policy and alice as its only publisher. +func newsletterEnv(t *testing.T) *env { + t.Helper() + e := newEnv(t) + if err := e.s.SetPolicies(e.list.ID, store.PostPublishers, store.JoinOpen, store.ArchivePrivate); err != nil { + t.Fatal(err) + } + if err := e.s.SetPublisher(e.list.ID, "alice@example.com", true); err != nil { + t.Fatal(err) + } + return e +} + +// nothingKept checks that a refused post left no trace: not held, not archived, not queued. +func nothingKept(t *testing.T, e *env) { + t.Helper() + if held, _ := e.s.ListHeld(e.list.ID); len(held) != 0 { + t.Fatalf("held: %+v", held) + } + if msgs, _, _ := e.s.ListMessages(e.list.ID, 10, 0); len(msgs) != 0 { + t.Fatalf("archived: %+v", msgs) + } + if st, _ := e.s.OutboxStats(); st.Pending != 0 { + t.Fatalf("queued: %+v", st) + } +} + +func TestAPublisherPostsToANewsletter(t *testing.T) { + e := newsletterEnv(t) + res, err := e.r.Route("Alice@Example.com", "dev@example.org", postFrom("Alice ")) + if err != nil { + t.Fatal(err) + } + if err := e.send(res); err != nil { + t.Fatal(err) + } + if len(e.out.Sent) != 2 { + t.Fatalf("every member receives it: sent %d", len(e.out.Sent)) + } +} + +func TestAPlainMemberMayNotPostToANewsletter(t *testing.T) { + e := newsletterEnv(t) + _, err := e.r.Route("bob@example.com", "dev@example.org", postFrom("bob@example.com")) + if !errors.Is(err, ErrNotPublisher) { + t.Fatalf("want ErrNotPublisher, got %v", err) + } + nothingKept(t, e) +} + +func TestAStrangerMayNotPostToANewsletter(t *testing.T) { + e := newsletterEnv(t) + for _, from := range []string{"mallory@evil.com", "alice@example.com"} { + _, err := e.r.Route("mallory@evil.com", "dev@example.org", postFrom(from)) + if !errors.Is(err, ErrNotPublisher) { + t.Fatalf("From %s: want ErrNotPublisher, got %v", from, err) + } + } + nothingKept(t, e) +} + +func TestAPublisherDisabledByBouncesStillPosts(t *testing.T) { + e := newsletterEnv(t) + for i := 0; i < store.BounceThreshold; i++ { + e.s.RecordHardBounce(e.alice, store.BounceThreshold) + } + res, err := e.r.Route("alice@example.com", "dev@example.org", postFrom("alice@example.com")) + if err != nil { + t.Fatal(err) + } + if len(res.Recipients) != 1 || res.Recipients[0].Address != "bob@example.com" { + t.Fatalf("a disabled publisher posts but does not receive: %+v", res.Recipients) + } +} + +func TestAPublisherWithAnotherFromHeaderIsHeld(t *testing.T) { + e := newsletterEnv(t) + _, err := e.r.Route("alice@example.com", "dev@example.org", postFrom("Bob ")) + if !errors.Is(err, ErrHeld) { + t.Fatalf("want ErrHeld, got %v", err) + } + held, _ := e.s.ListHeld(e.list.ID) + if len(held) != 1 || !strings.Contains(held[0].Reason, "From header does not match") { + t.Fatalf("held: %+v", held) + } + if st, _ := e.s.OutboxStats(); st.Pending != 0 { + t.Fatal("nothing may be queued") + } +} + +func TestAReleasedPublisherPostIsDelivered(t *testing.T) { + e := newsletterEnv(t) + e.r.Route("alice@example.com", "dev@example.org", postFrom("Bob ")) + held, _ := e.s.ListHeld(e.list.ID) + if err := e.release(held[0].ID); err != nil { + t.Fatal(err) + } + if len(e.out.Sent) != 2 { + t.Fatalf("the admin approved it: sent %d", len(e.out.Sent)) + } + if held, _ := e.s.ListHeld(e.list.ID); len(held) != 0 { + t.Fatal("released") + } +} + +func TestNewsletterDiscardRulesComeFirst(t *testing.T) { + e := newsletterEnv(t) + for _, sender := range []string{"alice@example.com", "bob@example.com", "stranger@x.com"} { + for _, h := range []string{"List-Id: \r\n", "Auto-Submitted: auto-replied\r\n"} { + if _, err := e.r.Route(sender, "dev@example.org", withHeaders(h)); !errors.Is(err, ErrDiscarded) { + t.Fatalf("%s %q: want ErrDiscarded, got %v", sender, h, err) + } + } + } + nothingKept(t, e) +} + +func TestAPublisherFlagChangesNothingOnOtherPolicies(t *testing.T) { + e := newEnv(t) + // members: a plain member posts, a stranger is refused as a non-member. + if _, err := e.r.Route("bob@example.com", "dev@example.org", postFrom("bob@example.com")); err != nil { + t.Fatalf("members policy: %v", err) + } + if _, err := e.r.Route("x@y.com", "dev@example.org", postFrom("x@y.com")); !errors.Is(err, ErrNotMember) { + t.Fatalf("members policy, stranger: %v", err) + } + // moderated: a publisher is held like everybody else. + e.s.SetPublisher(e.list.ID, "alice@example.com", true) + e.s.SetPolicies(e.list.ID, store.PostModerated, store.JoinOpen, store.ArchivePrivate) + if _, err := e.r.Route("alice@example.com", "dev@example.org", postFrom("alice@example.com")); !errors.Is(err, ErrHeld) { + t.Fatalf("moderated policy: %v", err) + } +} diff --git a/internal/router/router.go b/internal/router/router.go index 7e95813..7721ece 100644 --- a/internal/router/router.go +++ b/internal/router/router.go @@ -28,6 +28,8 @@ var ( ErrHeldTooLarge = store.ErrHeldTooLarge // ErrNotMember means the sender may not post to the list. ErrNotMember = errors.New("sender is not a member") + // ErrNotPublisher means the list takes posts from its publishers only and the sender is not one. + ErrNotPublisher = errors.New("sender is not a publisher") // ErrHeld means the message was queued for moderation. It is not a failure. ErrHeld = errors.New("held for moderation") // ErrBadToken means a confirmation or bounce token is invalid, used or expired. @@ -87,12 +89,23 @@ func (r *Router) Route(sender, rcpt string, data []byte) (Result, error) { if l.PostPolicy == store.PostModerated { return Result{}, r.hold(l, sender, data, "the list is moderated") } - ok, err := r.store.IsMember(l.ID, sender) - if err != nil { - return Result{}, err - } - if !ok { - return Result{}, ErrNotMember + if l.PostPolicy == store.PostPublishers { + // A newsletter: only its publishers may post. Everybody else is refused, never held. + ok, err := r.store.IsPublisher(l.ID, sender) + if err != nil { + return Result{}, err + } + if !ok { + return Result{}, ErrNotPublisher + } + } else { + ok, err := r.store.IsMember(l.ID, sender) + if err != nil { + return Result{}, err + } + if !ok { + return Result{}, ErrNotMember + } } // Membership is judged on the envelope sender, which anyone can forge, while the archive, the // rewritten From and Reply-To come from the From header. Only trust a post whose header names