mix/selfpost
1
0
Fork 0
Code Issues Pull Requests Actions 21 Packages Projects Releases Wiki Activity

e2e: a negative case passes only on its own refusal (audit stage 0)

Browse Source 
sendResult.refusedAt(stage, code, text) and replyIs(err, code, text):
nil only for the server's reply with that code and text at that stage;
a reset, a timeout or another reply is described for the failure.

- level 1: only anvil's "450 4.7.1 Error: too much mail from", only after
  a message of the loop was accepted. Held to that, it failed twice on
  the stand, each time for a real reason:
  1. waitForSMTPSReady took a TCP connect for readiness; Docker's port
     proxy accepts before Postfix listens and then resets - the reset
     once taken for the limit. It now waits for the TLS 220 greeting.
  2. the first message then got "553 ... not owned by user l1app": an
     smtpd idle from before the panel's postfix reload took the
     connection with the old sender_login_maps. The level-1 limit had
     never been what the case saw. The first message now waits (15 s at
     most) for the map, failing at once on any other refusal.
  Now: "level-1 limit tripped on attempt 51/60: 450 4.7.1 Error: too
  much mail from 10.77.0.1".
- level 2: 451 4.7.1 at MAIL, and both MAIL FROM of one connection.
- sender mismatch: 553 at RCPT, "not owned by user".
- no AUTH and the relay case: 554 "Client host rejected: Access
  denied" at RCPT; the relay case's comment claimed
  reject_unauth_destination, which on 465 comes after the client
  restriction - port 25 holds "554 Relay access denied".
- port 25: 550 5.1.1 for unknown recipients and report addresses.
- panel down: a 4xx reply (textproto), not just text starting with 4.

The product side (a second after an application is saved when its first
message can get 553) is written in the audit plan, not changed. Audit plan
line ticked with what was found, roadmap 7/61. No CHANGELOG line: tests only.

Evidence: make e2e on the test server for this tree, exit 0.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
mix
2026-10-14 14:10:47 +03:00
co-authored by Claude Opus 5.5
parent 8b9798884a
commit 96425dd515
6 changed files with 156 additions and 49 deletions
Download Patch File Download Diff File Expand all files Collapse all files
test/e2e/negative_test.go
+61 -31
View File
@@ -44,12 +44,9 @@ func testLevel2RateLimit(t *testing.T, sc *scenario) {
authLogin: login, authPassword: password,
from: from, to: recipient, subject: "e2e " + uniqueToken("l2-second"), body: "should be rejected",
})
if second.ok() {
t.Fatal("second message exceeding the level-2 limit was accepted, want rejected")
}
if second.mailErr == nil {
t.Fatalf("expected the level-2 rejection at MAIL FROM, got: dial=%v auth=%v rcpt=%v data=%v",
second.dialErr, second.authErr, second.rcptErr, second.dataErr)
// The milter answers tempfail at MAIL FROM, which Postfix words as below.
if err := second.refusedAt("MAIL", 451, "4.7.1 Service unavailable"); err != nil {
t.Fatalf("the second message over the level-2 limit: %v", err)
}
// The limit holds for every message of a connection, not for its first
@@ -59,8 +56,11 @@ func testLevel2RateLimit(t *testing.T, sc *scenario) {
// used to arrive with no client address and was let through (found by the
// technical review of 2026-10-12; the same hole let an application past its
// client-address list).
if errs := mailTwiceOnOneConnection(login, password, from); errs[0] == nil || errs[1] == nil {
t.Fatalf("over the level-2 limit, two MAIL FROM on one connection were answered %v and %v, want both refused", errs[0], errs[1])
errs := mailTwiceOnOneConnection(login, password, from)
for i, err := range errs {
if err := replyIs(err, 451, "4.7.1 Service unavailable"); err != nil {
t.Fatalf("over the level-2 limit, MAIL FROM %d of one connection: %v", i+1, err)
}
}
if err := waitFor("a rate-limited row for l2app in the send log", 15*time.Second, 500*time.Millisecond, func() (bool, error) {
@@ -86,15 +86,14 @@ func testSenderLoginMismatch(t *testing.T, sc *scenario) {
from: "someone@not-" + senderDomain, to: recipient,
subject: "e2e " + uniqueToken("mismatch"), body: "should be rejected",
})
if res.ok() {
t.Fatal("send with a sender the application does not own was accepted, want rejected")
}
// Postfix evaluates smtpd_sender_restrictions with smtpd_delay_reject=yes
// (the default): the mismatch is detected at MAIL FROM but the reject is
// only sent back at RCPT TO, so the error can land on either call here.
if res.mailErr == nil && res.rcptErr == nil {
t.Fatalf("expected the mismatch rejected at MAIL or RCPT, got: dial=%v auth=%v data=%v",
res.dialErr, res.authErr, res.dataErr)
// only sent back at RCPT TO.
if err := res.refusedAt("RCPT", 553, "5.7.1"); err != nil {
t.Fatalf("a sender the application does not own: %v", err)
}
if err := replyIs(res.rcptErr, 553, "Sender address rejected: not owned by user"); err != nil {
t.Fatalf("a sender the application does not own: %v", err)
}
}
@@ -106,24 +105,25 @@ func testNoAuthRejected(t *testing.T, sc *scenario) {
from: "anyone@unregistered.e2e.test", to: recipient,
subject: "e2e " + uniqueToken("noauth"), body: "should be rejected",
})
if res.ok() {
t.Fatal("unauthenticated send was accepted, want rejected")
if err := res.refusedAt("RCPT", 554, "Client host rejected: Access denied"); err != nil {
t.Fatalf("an unauthenticated send: %v", err)
}
}
// testForeignRelayRejected is plan C.4 negative check 3: a direct proof that
// this is not an open relay — even the exact recipient the positive path just
// delivered to is refused without AUTH (reject_unauth_destination).
// the submission port is not an open relay — even the exact recipient the
// positive path just delivered to is refused without AUTH. The refusal is
// smtpd_client_restrictions (permit_sasl_authenticated, reject), which on 465
// and 587 comes before reject_unauth_destination, so the reply is the same as
// check 1's; reject_unauth_destination's own "Relay access denied" is held on
// port 25 (testInboundRelay), where clients do not authenticate.
func testForeignRelayRejected(t *testing.T, sc *scenario) {
res := attemptSend(sendAttempt{
from: "anyone@unregistered.e2e.test", to: recipient,
subject: "e2e " + uniqueToken("relay"), body: "should be rejected",
})
if res.ok() {
t.Fatal("unauthenticated relay to an external destination was accepted, want reject_unauth_destination")
}
if res.rcptErr == nil && res.mailErr == nil {
t.Fatalf("expected rejection at MAIL or RCPT, got: dial=%v auth=%v data=%v", res.dialErr, res.authErr, res.dataErr)
if err := res.refusedAt("RCPT", 554, "Client host rejected: Access denied"); err != nil {
t.Fatalf("an unauthenticated relay to an external destination: %v", err)
}
}
@@ -172,23 +172,53 @@ func testSessionSurvivesRestart(t *testing.T, sc *scenario) {
// well past that count, so the result is unambiguous regardless of how much of
// the shared per-IP budget earlier subtests already spent (they stay well
// under 50 between them).
//
// Only anvil's own reply counts, and only after at least one message of the
// loop went through: the case once passed on "limit tripped on attempt 1/60"
// when the connection was reset because Postfix was still starting - and,
// held to anvil's reply, it turned out the first message had always been
// refused for another reason (below).
func testLevel1RateLimit(t *testing.T, sc *scenario) {
login, password, err := sc.panel.addApplication(sc.domainID, "l1app", "wildcard", "")
if err != nil {
t.Fatalf("add application: %v", err)
}
const maxAttempts = 60
for i := 0; i < maxAttempts; i++ {
res := attemptSend(sendAttempt{
send := func() sendResult {
return attemptSend(sendAttempt{
authLogin: login, authPassword: password,
from: "l1@" + senderDomain, to: recipient,
subject: "e2e " + uniqueToken("l1"), body: "rate limit probe",
})
if !res.ok() {
t.Logf("level-1 limit tripped on attempt %d/%d: %v", i+1, maxAttempts, res.firstErr())
return
}
// The panel writes sender_login_maps and reloads Postfix, but an smtpd
// process that was idle before the reload can still take the next
// connection with the old map and answer 553 for the new login (seen on
// the stand: the process that greeted waitForSMTPSReady). Wait for the map
// to take effect; any other refusal fails at once.
deadline := time.Now().Add(15 * time.Second)
for {
res := send()
if res.ok() {
break
}
if res.refusedAt("RCPT", 553, "not owned by user "+login) != nil || time.Now().After(deadline) {
t.Fatalf("the first message of %s, before any limit could trip: %v", login, res.firstErr())
}
time.Sleep(300 * time.Millisecond)
}
const maxAttempts = 60
for i := 1; i < maxAttempts; i++ {
res := send()
if res.ok() {
continue
}
if err := res.refusedAt("MAIL", 450, "4.7.1 Error: too much mail from"); err != nil {
t.Fatalf("attempt %d/%d: %v", i+1, maxAttempts, err)
}
t.Logf("level-1 limit tripped on attempt %d/%d: %v", i+1, maxAttempts, res.firstErr())
return
}
t.Fatalf("level-1 rate limit (RATE_LIMIT_MESSAGES_PER_IP=50) never tripped after %d sends", maxAttempts)
}