fix(security): bound the moderation queue

- Cap the held queue at 500 per list and drop messages nobody moderated for 30 days
- Answer 452 when it is full, so a legitimate sender retries and a spam run goes away
This commit is contained in:
tgiachi 2026-11-09 20:26:33 +01:00
commit fd113c4ac2
6 changed files with 107 additions and 1 deletions

View file

@ -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):

View file

@ -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"])
}
}

View file

@ -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)
}
}

View file

@ -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.

View file

@ -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)
}
}

View file

@ -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<?`, listID, now.Add(-heldTTL).Unix()); err != nil {
return 0, err
}
var n int
if err := s.db.QueryRow(`SELECT COUNT(*) FROM held WHERE list_id=?`, listID).Scan(&n); err != nil {
return 0, err
}
if n >= 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
}