diff --git a/internal/ingest/ingest.go b/internal/ingest/ingest.go index 45556ee..45920a6 100644 --- a/internal/ingest/ingest.go +++ b/internal/ingest/ingest.go @@ -90,6 +90,8 @@ func (s *session) status(rcpt string, err error) error { return nil case errors.Is(err, router.ErrUnknownList): return &smtp.SMTPError{Code: 550, EnhancedCode: smtp.EnhancedCode{5, 1, 1}, Message: "no such list"} + case errors.Is(err, router.ErrHeldFull): + return &smtp.SMTPError{Code: 452, EnhancedCode: smtp.EnhancedCode{4, 2, 2}, Message: "the moderation queue of this list is full, try again later"} 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.ErrBadToken): diff --git a/internal/ingest/ingest_test.go b/internal/ingest/ingest_test.go index 8e4b8df..1eecfa3 100644 --- a/internal/ingest/ingest_test.go +++ b/internal/ingest/ingest_test.go @@ -275,3 +275,17 @@ func TestAutoReplyAndLoopsAreAcceptedButNotDelivered(t *testing.T) { t.Fatal("nothing may be queued") } } + +func TestAFullModerationQueueAnswers452(t *testing.T) { + st := newStack(t, nil) + l, _ := st.store.FindList("dev@example.org") + st.store.SetPolicies(l.ID, store.PostModerated, store.JoinOpen, store.ArchivePrivate) + for i := 0; i < 500; i++ { + st.store.HoldMessage(l.ID, "x@y.com", []byte("Subject: s\r\n\r\nb"), "r") + } + 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 != 452 { + t.Fatalf("a temporary refusal, so a legitimate sender retries later and a spam run goes away: %v", res["dev@example.org"]) + } +} diff --git a/internal/router/identity_test.go b/internal/router/identity_test.go index 441c3d2..0084f1c 100644 --- a/internal/router/identity_test.go +++ b/internal/router/identity_test.go @@ -95,3 +95,17 @@ func TestAnApprovedIdentityMismatchIsDelivered(t *testing.T) { t.Fatalf("the admin approved it: sent %d", len(e.out.Sent)) } } + +func TestAFullModerationQueueRefusesTemporarily(t *testing.T) { + e := newEnv(t) + e.s.SetPolicies(e.list.ID, "moderated", "open", "private") + for i := 0; i < 500; i++ { + if _, err := e.s.HoldMessage(e.list.ID, "x@y.com", []byte("Subject: s\r\n\r\nb"), "r"); err != nil { + t.Fatal(err) + } + } + _, err := e.r.Route("alice@example.com", "dev@example.org", postFrom("alice@example.com")) + if !errors.Is(err, ErrHeldFull) { + t.Fatalf("want ErrHeldFull, got %v", err) + } +} diff --git a/internal/router/router.go b/internal/router/router.go index c5a46c3..697e5fa 100644 --- a/internal/router/router.go +++ b/internal/router/router.go @@ -20,6 +20,8 @@ var ( // ErrDiscarded means the message was dropped on purpose (a loop or an automatic reply). It is // acknowledged to the MTA: refusing it would make the sender's server bounce it, starting a new loop. ErrDiscarded = errors.New("discarded") + // ErrHeldFull means the list's moderation queue is full: refuse for now, the sender may retry. + ErrHeldFull = store.ErrHeldFull // ErrNotMember means the sender may not post to the list. ErrNotMember = errors.New("sender is not a member") // ErrHeld means the message was queued for moderation. It is not a failure. diff --git a/internal/store/m2_test.go b/internal/store/m2_test.go index 1005aae..e86e452 100644 --- a/internal/store/m2_test.go +++ b/internal/store/m2_test.go @@ -269,3 +269,59 @@ func TestConfirmationMailHasAGlobalCap(t *testing.T) { t.Fatal("the global allowance returns after an hour") } } + +func TestHeldQueueHasACap(t *testing.T) { + s := newTestStore(t) + a, _ := s.CreateList("a", "example.org", "A") + b, _ := s.CreateList("b", "example.org", "B") + ids := make([]int64, 0, maxHeldPerList) + for i := 0; i < maxHeldPerList; i++ { + id, err := s.HoldMessage(a.ID, "x@y.com", []byte("Subject: s\r\n\r\nb"), "r") + if err != nil { + t.Fatalf("message %d: %v", i+1, err) + } + ids = append(ids, id) + } + if _, err := s.HoldMessage(a.ID, "x@y.com", []byte("x"), "r"); !errors.Is(err, ErrHeldFull) { + t.Fatalf("want ErrHeldFull, got %v", err) + } + if _, err := s.HoldMessage(b.ID, "x@y.com", []byte("x"), "r"); err != nil { + t.Fatalf("another list has its own allowance: %v", err) + } + // Moderating frees room. + if err := s.DeleteHeld(ids[0]); err != nil { + t.Fatal(err) + } + if _, err := s.HoldMessage(a.ID, "x@y.com", []byte("x"), "r"); err != nil { + t.Fatalf("after discarding one: %v", err) + } +} + +func TestOldHeldMessagesExpire(t *testing.T) { + s := newTestStore(t) + now := time.Unix(1_000_000, 0) + s.Now = func() time.Time { return now } + l, _ := s.CreateList("dev", "example.org", "Dev") + other, _ := s.CreateList("ops", "example.org", "Ops") + old, _ := s.HoldMessage(l.ID, "x@y.com", []byte("old"), "r") + oldOther, _ := s.HoldMessage(other.ID, "x@y.com", []byte("old elsewhere"), "r") + + now = now.Add(heldTTL - time.Hour) + fresh, _ := s.HoldMessage(l.ID, "x@y.com", []byte("fresh"), "r") + if _, err := s.GetHeld(old); err != nil { + t.Fatal("not expired yet") + } + now = now.Add(2 * time.Hour) // the first message is now older than the limit + if _, err := s.HoldMessage(l.ID, "x@y.com", []byte("newest"), "r"); err != nil { + t.Fatal(err) + } + if _, err := s.GetHeld(old); !errors.Is(err, ErrNotFound) { + t.Fatal("a message nobody moderated for a month is dropped") + } + if _, err := s.GetHeld(fresh); err != nil { + t.Fatalf("a recent message stays: %v", err) + } + if _, err := s.GetHeld(oldOther); err != nil { + t.Fatalf("expiry is applied to the list being written to, not to others: %v", err) + } +} diff --git a/internal/store/store.go b/internal/store/store.go index 6f0b196..0c0015f 100644 --- a/internal/store/store.go +++ b/internal/store/store.go @@ -16,6 +16,8 @@ import ( var ( // ErrNotFound is returned when a record does not exist. ErrNotFound = errors.New("not found") + // ErrHeldFull is returned when a list's moderation queue has no more room. + ErrHeldFull = errors.New("moderation queue is full") // ErrExists is returned when creating something that already exists. ErrExists = errors.New("already exists") ) @@ -51,6 +53,11 @@ const ( // Caps on confirmation mail, per hour. Anyone can name any address in a join request, so the // daemon must not mail one victim many times (maxPendingPerAddress, across all lists) or send // an unbounded amount in total (maxPendingPerHour). + // A moderated list could be flooded with mail that nobody reads: the queue per list is bounded, + // and a message nobody moderated for a month is dropped. + maxHeldPerList = 500 + heldTTL = 30 * 24 * time.Hour + maxPendingPerAddress = 3 maxPendingPerHour = 300 ) @@ -456,8 +463,19 @@ func (s *Store) HoldMessage(listID int64, sender string, data []byte, reason str if data == nil { data = []byte{} // the column is NOT NULL } + now := s.Now() + if _, err := s.db.Exec(`DELETE FROM held WHERE list_id=? AND created_at= maxHeldPerList { + return 0, ErrHeldFull + } res, err := s.db.Exec(`INSERT INTO held(list_id, sender, data, created_at, reason) VALUES(?,?,?,?,?)`, - listID, norm(sender), data, s.Now().Unix(), reason) + listID, norm(sender), data, now.Unix(), reason) if err != nil { return 0, err }