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:
parent
bad3c9bc10
commit
fd113c4ac2
6 changed files with 107 additions and 1 deletions
|
|
@ -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):
|
||||
|
|
|
|||
|
|
@ -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"])
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in a new issue