SMTP: STARTTLS, smuggling fix, and RFC 5321 conformance

Security:
- SMTP smuggling (CVE-2023-51764 family): only <CRLF>.<CRLF> ends DATA
  (strict CRLF framing); bare CR/LF in the text is stored as CR LF.
  Before, '<LF>.<LF>' and four other variants ended the message and the
  rest ran as fresh commands - a second, forged message was delivered.
- STARTTLS on port 25 (RFC 3207), using the configured tls cert; AUTH
  is only offered/accepted once encrypted (538 5.7.11 otherwise).
- The 250 reply no longer discloses the queue file's full path.
- Queue file names %-encode the addresses ('/' or '|' in an address
  broke the name or pointed it into another directory).

Conformance (RFC 5321, 1870, 2034, 2920, 3207, 3463, 3848, 4616, 4954,
6152):
- 500 for unknown/empty/over-long commands (no reply at all before -
  clients hung); 501 for missing/invalid arguments (bare MAIL/RCPT/HELO
  were out-of-bounds reads).
- HELO/EHLO required before MAIL; nested MAIL refused; EHLO/HELO/RSET/
  end-of-DATA reset the transaction.
- MAIL: SIZE= (552 when over the limit), BODY=7BIT|8BITMIME, AUTH=;
  555 for anything else; case-insensitive keywords; address syntax
  checked.
- RCPT: postmaster (bare and any case) accepted; case-insensitive
  domain and local-part; 550 5.1.1 unknown user vs 550 5.7.1 relay
  denied; aliases accepted (they were rejected at RCPT before); 1000
  recipient cap (452 4.5.3).
- ENHANCEDSTATUSCODES advertised and used on every reply.
- AUTH PLAIN added alongside LOGIN; strict base64; 535 5.7.8 on
  failure; 503 before EHLO, during a transaction, or when already
  authenticated (the last one sent no reply before).
- Received: per RFC 5321 4.4 with client IP, protocol per RFC 3848
  (ESMTP/ESMTPS/ESMTPSA) and queue id; Return-Path: added at local
  delivery.

tests/smtp_conformance.py: 112 checks. origin/master passes 37 of the
72 it can reach before the server stops answering; this passes 112/112.
tests/imap_pop3_regression.py: IMAPS/POP3S unaffected (3/3).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0121tAhQVe4qbCwYgVjKQS4B
This commit is contained in:
barantandClaude Opus 5.5 authored and brad Arant committed 2026-11-02 11:56:41 -08:00
1 parent 407cc2e915
commit d3d7e5f3e5
27 files changed
+1821 -358

No files matched your search

+538
View File
@@ -0,0 +1,538 @@
#!/usr/bin/env python3
"""
SMTP server conformance + robustness suite for BARANTMail.
Usage: smtp_conformance.py <plain_port> <implicit_tls_port> <mail_dir> [--json out.json]
Run it against a test instance, never production: it delivers real
messages to the test mailboxes. Setup used for the results in the commit
message: a throwaway barantmail.cfg with smtp/smtpTLS/imap/pop3 ports, a
self-signed "tls" cert, and tests/nxdns.py serving NXDOMAIN on
127.0.0.1:53 (resolv.conf pointed at it) so SPF/DMARC lookups answer
immediately and deterministically.
Every check names the spec section it enforces. "MUST"-level requirements
and security properties are tagged; a few SHOULD-level behaviours are
tagged SHOULD. Test mailboxes expected under <mail_dir>:
mail.test/brad (.password = "secret")
mail.test/postmaster
"""
import base64, glob, json, os, re, socket, ssl, sys, threading, time
PLAIN, IMPLICIT, MAILDIR = int(sys.argv[1]), int(sys.argv[2]), sys.argv[3]
JSON_OUT = sys.argv[sys.argv.index("--json") + 1] if "--json" in sys.argv else None
HOST = "127.0.0.1"
LOCAL = "mail.test"
USER, PASSWORD = "brad@mail.test", "secret"
INBOX = os.path.join(MAILDIR, "mail.test", "brad", "Inbox")
PM_INBOX = os.path.join(MAILDIR, "mail.test", "postmaster", "Inbox")
ENH = re.compile(r"^[245]\d\d[ -][245]\.\d{1,3}\.\d{1,3}(\s|$)")
results = []
def check(group, name, ok, detail="", level="MUST"):
results.append({"group": group, "name": name, "ok": bool(ok), "level": level,
"detail": "" if ok else repr(detail)[:240]})
print(("PASS " if ok else "FAIL ") + "[%s] %s" % (group, name) + ("" if ok else "\n -> " + repr(detail)[:240]))
def tls_ctx():
c = ssl.create_default_context(); c.check_hostname = False; c.verify_mode = ssl.CERT_NONE
return c
class S:
"""One SMTP client connection."""
def __init__(self, port=PLAIN, implicit=False, timeout=5):
self.sock = socket.create_connection((HOST, port), timeout=timeout)
if implicit:
self.sock = tls_ctx().wrap_socket(self.sock, server_hostname=LOCAL)
self.buf = b""
self.greeting = self.reply()
def send(self, data):
if isinstance(data, str): data = data.encode()
self.sock.sendall(data)
def reply(self, timeout=None):
if timeout is not None: self.sock.settimeout(timeout)
lines = []
try:
while True:
while b"\r\n" not in self.buf:
chunk = self.sock.recv(65536)
if not chunk:
raise EOFError("connection closed after %r" % lines)
self.buf += chunk
line, self.buf = self.buf.split(b"\r\n", 1)
lines.append(line.decode("utf-8", "replace"))
if len(line) < 4 or line[3:4] != b"-":
return lines
finally:
if timeout is not None: self.sock.settimeout(5)
def cmd(self, line):
self.send(line + "\r\n")
return self.reply()
def code(self, line):
return self.cmd(line)[-1][:3]
def ehlo(self, name="client.test"):
return self.cmd("EHLO " + name)
def starttls(self):
r = self.cmd("STARTTLS")
if not r[-1].startswith("220"): raise RuntimeError("STARTTLS refused: %r" % r)
self.sock = tls_ctx().wrap_socket(self.sock, server_hostname=LOCAL)
self.buf = b""
return r
def silent(self, wait=1.0):
"""True if the server sends nothing more within `wait` seconds."""
if self.buf: return False
self.sock.settimeout(wait)
try:
d = self.sock.recv(4096)
self.buf += d
return False if d else True
except (socket.timeout, TimeoutError, ssl.SSLError):
return True
finally:
self.sock.settimeout(5)
def close(self):
try: self.sock.close()
except Exception: pass
def code(r): return r[-1][:3]
def has_enh(r): return bool(ENH.match(r[-1]))
def b64(s): return base64.b64encode(s.encode() if isinstance(s, str) else s).decode()
def run(group, fn):
try:
fn()
except Exception as e:
check(group, "(suite step raised) " + fn.__name__, False, e)
def inbox_files(path=INBOX):
return set(glob.glob(os.path.join(path, "*")))
def wait_new(before, path=INBOX, n=1, timeout=8):
end = time.time() + timeout
while time.time() < end:
new = inbox_files(path) - before
if len(new) >= n:
time.sleep(0.2)
return sorted(inbox_files(path) - before, key=os.path.getmtime)
time.sleep(0.1)
return sorted(inbox_files(path) - before, key=os.path.getmtime)
def deliver(s, body, frm="sender@client.test", rcpt=USER):
"""Run one transaction on an EHLO'd session; return (final reply, delivered file contents)."""
before = inbox_files()
s.cmd("MAIL FROM:<%s>" % frm)
s.cmd("RCPT TO:<%s>" % rcpt)
r = s.cmd("DATA")
if code(r) != "354": return r, None
s.send(body)
r = s.reply(timeout=15)
files = wait_new(before) if code(r) == "250" else []
return r, (open(files[-1], "rb").read() if files else None)
# ---------------------------------------------------------------- greeting
def t_greeting():
s = S()
check("greeting", "220 greeting naming the server (RFC 5321 4.2, 4.3.1)",
s.greeting[-1].startswith("220 " + LOCAL), s.greeting)
s.close()
# ---------------------------------------------------------------- command parsing
def t_parsing():
s = S(); s.ehlo()
r = s.cmd("FROB the knob")
check("parsing", "unknown command -> 500 (RFC 5321 4.2.4)", code(r) == "500", r)
r = s.cmd("")
check("parsing", "empty command line -> 500 (RFC 5321 4.2.4)", code(r) == "500", r)
r = s.cmd("noop")
check("parsing", "verbs are case-insensitive (RFC 5321 2.4)", code(r) == "250", r)
r = s.cmd("mail from:<a@client.test>")
check("parsing", "'mail from:' accepted in lower case (RFC 5321 2.4)", code(r) == "250", r)
r = s.cmd("rcpt to:<%s>" % USER)
check("parsing", "'rcpt to:' accepted in lower case (RFC 5321 2.4)", code(r) == "250", r)
s.cmd("RSET")
for verb in ("MAIL", "RCPT", "HELO", "VRFY"):
r = s.cmd(verb)
check("parsing", "%s with no argument -> 501, no crash (RFC 5321 4.1.1)" % verb, code(r) in ("501", "503"), r)
r = s.cmd("NOOP " + "x" * 20000)
check("parsing", "over-long command line -> 500 'line too long' (RFC 5321 4.5.3.1.4)", code(r) == "500", r)
r = s.cmd("NOOP")
check("parsing", "session still usable after over-long line", code(r) == "250", r)
s.close()
# ---------------------------------------------------------------- EHLO / HELO
def t_ehlo():
s = S()
r = s.cmd("EHLO")
check("ehlo", "EHLO without domain -> 501 (RFC 5321 4.1.1.1)", code(r) == "501", r)
r = s.ehlo()
kw = [l[4:].split(" ")[0].upper() for l in r[1:]]
check("ehlo", "first line 250-<domain> (RFC 5321 4.1.1.1)", r[0].startswith("250-" + LOCAL) or r[0].startswith("250 " + LOCAL), r)
check("ehlo", "advertises PIPELINING (RFC 2920)", "PIPELINING" in kw, r, "SHOULD")
check("ehlo", "advertises 8BITMIME (RFC 6152)", "8BITMIME" in kw, r, "SHOULD")
check("ehlo", "advertises SIZE with a limit (RFC 1870)", any(re.match(r"^250[ -]SIZE \d+$", l) for l in r), r, "SHOULD")
check("ehlo", "advertises ENHANCEDSTATUSCODES (RFC 2034)", "ENHANCEDSTATUSCODES" in kw, r, "SHOULD")
check("ehlo", "advertises STARTTLS on port 25 (RFC 3207)", "STARTTLS" in kw, r)
check("ehlo", "no plain-text AUTH offered before TLS (RFC 4954 4, 14)", "AUTH" not in kw, r, "SHOULD")
s.close()
s = S()
r = s.cmd("HELO")
check("ehlo", "HELO without domain -> 501 (RFC 5321 4.1.1.1)", code(r) == "501", r)
r = s.cmd("HELO client.test")
check("ehlo", "HELO client.test -> 250", code(r) == "250", r)
s.close()
def t_enhanced():
s = S(); s.ehlo()
probes = ["NOOP", "MAIL FROM:<a@client.test>", "RCPT TO:<%s>" % USER, "RSET",
"RCPT TO:<%s>" % USER, "FROB", "VRFY brad", "HELP", "MAIL FROM:<a@client.test> FROB=1"]
bad = []
for p in probes:
r = s.cmd(p)
if not has_enh(r): bad.append((p, r[-1]))
check("enhanced", "every 2xx/4xx/5xx reply after EHLO carries an enhanced code (RFC 2034 3, RFC 3463)", not bad, bad)
s.close()
# ---------------------------------------------------------------- sequencing
def t_sequence():
s = S()
r = s.cmd("MAIL FROM:<a@client.test>")
check("sequence", "MAIL before HELO/EHLO -> 503 (RFC 5321 4.1.4)", code(r) == "503", r)
s.ehlo()
r = s.cmd("RCPT TO:<%s>" % USER)
check("sequence", "RCPT before MAIL -> 503 (RFC 5321 4.1.4)", code(r) == "503", r)
r = s.cmd("DATA")
check("sequence", "DATA before MAIL/RCPT -> 503 (RFC 5321 4.1.4)", code(r) in ("503", "554"), r)
s.cmd("MAIL FROM:<a@client.test>")
r = s.cmd("MAIL FROM:<b@client.test>")
check("sequence", "nested MAIL inside a transaction -> 503 (RFC 5321 4.1.4)", code(r) == "503", r)
r = s.cmd("DATA")
check("sequence", "DATA with no accepted RCPT -> 503/554 (RFC 5321 3.3)", code(r) in ("503", "554"), r)
s.cmd("RCPT TO:<%s>" % USER)
s.ehlo()
r = s.cmd("RCPT TO:<%s>" % USER)
check("sequence", "EHLO resets the transaction like RSET (RFC 5321 4.1.4)", code(r) == "503", r)
s.cmd("MAIL FROM:<a@client.test>"); s.cmd("RCPT TO:<%s>" % USER)
r = s.cmd("RSET")
check("sequence", "RSET -> 250 (RFC 5321 4.1.1.5)", code(r) == "250", r)
r = s.cmd("RCPT TO:<%s>" % USER)
check("sequence", "RSET clears MAIL/RCPT state", code(r) == "503", r)
r = s.cmd("MAIL FROM:<a@client.test>")
check("sequence", "RSET keeps the EHLO (new MAIL allowed without re-EHLO)", code(r) == "250", r)
s.cmd("RSET")
r = s.cmd("RSET now")
check("sequence", "RSET with an argument -> 501 (RFC 5321 4.1.1.5)", code(r) == "501", r, "SHOULD")
s.close()
# ---------------------------------------------------------------- MAIL
def t_mail():
s = S(); s.ehlo()
r = s.cmd("MAIL FROM:<a@client.test>")
check("mail", "MAIL FROM:<addr> -> 250 (RFC 5321 4.1.1.2)", code(r) == "250", r); s.cmd("RSET")
r = s.cmd("MAIL FROM:<>")
check("mail", "null reverse-path <> accepted (RFC 5321 4.5.5)", code(r) == "250", r); s.cmd("RSET")
r = s.cmd("MAIL FROM:<a@client.test> SIZE=99999999999")
check("mail", "declared SIZE over the limit -> 552 (RFC 1870 6.1)", code(r) == "552", r); s.cmd("RSET")
r = s.cmd("MAIL FROM:<a@client.test> SIZE=1000 BODY=8BITMIME")
check("mail", "SIZE= and BODY=8BITMIME parameters accepted (RFC 1870, RFC 6152)", code(r) == "250", r); s.cmd("RSET")
r = s.cmd("MAIL FROM:<a@client.test> BODY=7BIT")
check("mail", "BODY=7BIT accepted (RFC 6152 3)", code(r) == "250", r); s.cmd("RSET")
r = s.cmd("MAIL FROM:<a@client.test> FROB=1")
check("mail", "unknown MAIL parameter -> 555 (RFC 5321 4.1.1.11)", code(r) == "555", r); s.cmd("RSET")
r = s.cmd("MAIL FROM:a@client.test")
check("mail", "reverse-path without <> -> 501 (RFC 5321 4.1.2)", code(r) == "501", r); s.cmd("RSET")
r = s.cmd("MAIL TO:<a@client.test>")
check("mail", "malformed MAIL -> 501 (RFC 5321 4.2.2)", code(r) == "501", r)
s.close()
# ---------------------------------------------------------------- RCPT
def t_rcpt():
s = S(); s.ehlo(); s.cmd("MAIL FROM:<a@client.test>")
r = s.cmd("RCPT TO:<%s>" % USER)
check("rcpt", "local mailbox -> 250 (RFC 5321 4.1.1.3)", code(r) == "250", r)
r = s.cmd("RCPT TO:<brad@MAIL.TEST>")
check("rcpt", "domain matched case-insensitively (RFC 5321 2.4)", code(r) == "250", r)
r = s.cmd("RCPT TO:<Brad@mail.test>")
check("rcpt", "local-part matched case-insensitively for existing mailbox (RFC 5321 2.4)", code(r) == "250", r, "SHOULD")
r = s.cmd("RCPT TO:<nobody@mail.test>")
check("rcpt", "unknown local user -> 550 5.1.1 (RFC 5321 4.2.2, RFC 3463)", code(r) == "550" and " 5.1.1" in r[-1], r)
r = s.cmd("RCPT TO:<victim@elsewhere.example>")
check("rcpt", "unauthenticated relay refused -> 550/554 5.7.1 (RFC 5321 3.6.2, 7.1)", code(r) in ("550", "554") and " 5.7.1" in r[-1], r)
r = s.cmd("RCPT TO:<postmaster>")
check("rcpt", "<postmaster> with no domain accepted (RFC 5321 4.5.1 MUST)", code(r) == "250", r)
r = s.cmd("RCPT TO:<PostMaster@mail.test>")
check("rcpt", "postmaster local-part case-insensitive (RFC 5321 4.5.1)", code(r) == "250", r)
r = s.cmd("RCPT TO:<%s> NOTIFY=NEVER" % USER)
check("rcpt", "unsupported RCPT parameter -> 555 (RFC 5321 4.1.1.11)", code(r) == "555", r)
r = s.cmd("RCPT TO:brad@mail.test")
check("rcpt", "forward-path without <> -> 501 (RFC 5321 4.1.2)", code(r) == "501", r)
r = s.cmd("RCPT TO:<justaname>")
check("rcpt", "address without @ (not postmaster) rejected, no crash", code(r) in ("501", "550", "553"), r)
r = s.cmd("NOOP")
check("rcpt", "server still answering after malformed recipients", code(r) == "250", r)
s.cmd("RSET"); s.cmd("MAIL FROM:<a@client.test>")
codes = [code(s.cmd("RCPT TO:<%s>" % USER)) for _ in range(100)]
check("rcpt", "100 recipients accepted in one transaction (RFC 5321 4.5.3.1.8)", codes.count("250") == 100, codes[-3:])
s.close()
# ---------------------------------------------------------------- DATA
def t_data():
s = S(); s.ehlo()
s.cmd("MAIL FROM:<a@client.test>"); s.cmd("RCPT TO:<%s>" % USER)
r = s.cmd("DATA now")
check("data", "DATA with an argument -> 501 (RFC 5321 4.1.1.4)", code(r) == "501", r, "SHOULD")
s.cmd("RSET")
body = ("Subject: conformance dot test\r\nFrom: <sender@client.test>\r\n\r\n"
"first line\r\n..leading dot stuffed\r\n.\r\n").encode()
# the data above is already terminated; dot line ".." must come back as "."
r, msg = deliver(s, body)
check("data", "message accepted -> 250 (RFC 5321 4.1.1.4)", code(r) == "250", r)
check("data", "queue ID in reply does not leak server filesystem paths", "/" not in r[-1], r, "SHOULD")
if msg is None:
check("data", "message delivered to local mailbox", False, "nothing appeared in Inbox")
else:
text = msg.decode("utf-8", "replace")
check("data", "dot-unstuffing: '..x' stored as '.x' (RFC 5321 4.5.2)", "\r\n.leading dot stuffed\r\n" in text and "..leading" not in text, text[-200:])
check("data", "Received: trace header prepended (RFC 5321 4.4 MUST)", re.search(r"(?m)^Received: from ", text) is not None, text[:300])
check("data", "Received header has 'by <host>' and 'with ESMTP' (RFC 5321 4.4, RFC 3848)",
re.search(r"by %s.*with ESMTP" % re.escape(LOCAL), text, re.S) is not None, text[:300])
check("data", "Received header records client IP (RFC 5321 4.4 SHOULD)", "[127.0.0.1]" in text[:600], text[:300], "SHOULD")
check("data", "Return-Path added at final delivery (RFC 5321 4.4 MUST)",
text.startswith("Return-Path: <sender@client.test>"), text[:120])
check("data", "stored lines are CRLF-terminated", "\n" not in text.replace("\r\n", ""), "bare LF in stored message", "SHOULD")
r = s.cmd("RCPT TO:<%s>" % USER)
check("data", "transaction cleared after DATA completes (RFC 5321 4.1.1.4)", code(r) == "503", r)
s.close()
def t_split_crlf():
# A CR LF split across two TCP segments must still be one line ending.
s = S(); s.ehlo()
before = inbox_files()
s.cmd("MAIL FROM:<sender@client.test>"); s.cmd("RCPT TO:<%s>" % USER); s.cmd("DATA")
s.send(b"Subject: split crlf\r\n\r\nalpha\r"); time.sleep(0.4)
s.send(b"\nbeta\r\n.\r\n")
r = s.reply(timeout=10)
new = wait_new(before)
msg = open(new[-1], "rb").read() if new else b""
check("data", "CR LF split across reads is one line ending - no blank line inserted (RFC 5321 2.3.8)",
code(r) == "250" and b"alpha\r\nbeta\r\n" in msg, (r, msg[-60:]))
s.close()
def t_size():
s = S(); s.ehlo()
s.cmd("MAIL FROM:<a@client.test>"); s.cmd("RCPT TO:<%s>" % USER); s.cmd("DATA")
chunk = ("X" * 998 + "\r\n").encode()
blob = chunk * (27 * 1024) # ~27 MB > 25 MB limit
s.send(blob + b".\r\n")
r = s.reply(timeout=60)
check("size", "message over SIZE limit -> 552 after DATA (RFC 1870 6.3, RFC 5321 4.5.3.1.10)", code(r) == "552", r)
r = s.cmd("NOOP")
check("size", "session still usable after oversized message", code(r) == "250", r)
s.close()
def t_smuggling():
# SMTP smuggling (CVE-2023-51764/51765/51766 family): only <CRLF>.<CRLF>
# ends DATA (RFC 5321 4.1.1.4 / 2.3.8); bare-LF / bare-CR variants must not.
variants = {"<LF>.<LF>": b"\n.\n", "<LF>.<CR><LF>": b"\n.\r\n", "<CR><LF>.<LF>": b"\r\n.\n",
"<CR>.<CR>": b"\r.\r", "<CR><LF>.<CR>": b"\r\n.\r"}
for name, term in variants.items():
s = S(); s.ehlo()
before = inbox_files()
s.cmd("MAIL FROM:<sender@client.test>"); s.cmd("RCPT TO:<%s>" % USER); s.cmd("DATA")
body = (b"Subject: carrier\r\n\r\nhello" + term +
b"MAIL FROM:<forged@paypal.example>\r\nRCPT TO:<" + USER.encode() + b">\r\nDATA\r\n"
b"Subject: SMUGGLED\r\n\r\nsmuggled\r\n.\r\n")
s.send(body)
try:
r = s.reply(timeout=10)
except Exception as e:
r = [repr(e)]
extra = not s.silent(1.5)
new = wait_new(before, timeout=4)
contents = b"".join(open(f, "rb").read() for f in new)
# Smuggled = a SEPARATE message (its own header section) with the
# forged subject. The text staying inside the one carrier message's
# body is the correct outcome.
def header_subject(data):
head = data.split(b"\r\n\r\n", 1)[0]
m = re.search(rb"(?mi)^Subject: (.*)$", head)
return m.group(1).strip() if m else b""
smuggled = any(header_subject(open(f, "rb").read()) == b"SMUGGLED" for f in new)
ok = code(r) == "250" and not extra and len(new) == 1 and not smuggled
# it's also acceptable to reject the whole message outright for bare line endings
ok = ok or (code(r) in ("550", "554", "500") and not extra and not smuggled)
check("smuggling", "%s inside DATA does not end the message (RFC 5321 2.3.8, 4.1.1.4)" % name, ok,
(r, "extra replies" if extra else "", len(new), "smuggled" if smuggled else ""))
s.close()
def t_pipelining():
s = S(); s.ehlo()
s.send("MAIL FROM:<a@client.test>\r\nRCPT TO:<%s>\r\nRCPT TO:<nobody@mail.test>\r\nDATA\r\n" % USER)
codes = [code(s.reply()) for _ in range(4)]
check("pipelining", "pipelined MAIL/RCPT/RCPT/DATA answered in order (RFC 2920 3.1)", codes == ["250", "250", "550", "354"], codes)
s.send(".\r\nQUIT\r\n")
codes = [code(s.reply()) for _ in range(2)]
check("pipelining", "end-of-data then QUIT answered in order", codes == ["250", "221"], codes)
s.close()
# ---------------------------------------------------------------- misc commands
def t_misc():
s = S(); s.ehlo()
r = s.cmd("NOOP"); check("misc", "NOOP -> 250 (RFC 5321 4.1.1.9)", code(r) == "250", r)
r = s.cmd("NOOP hello"); check("misc", "NOOP with a string -> 250 (RFC 5321 4.1.1.9)", code(r) == "250", r)
r = s.cmd("VRFY brad"); check("misc", "VRFY -> 250/251/252/550/553/502 (RFC 5321 3.5.3)", code(r) in ("250", "251", "252", "502", "550", "553"), r)
r = s.cmd("EXPN staff"); check("misc", "EXPN -> 250/252/502/550 (RFC 5321 3.5.3)", code(r) in ("250", "252", "502", "550"), r)
r = s.cmd("HELP"); check("misc", "HELP -> 211/214 (RFC 5321 4.1.1.8)", code(r) in ("211", "214"), r)
s.cmd("MAIL FROM:<a@client.test>"); s.cmd("RCPT TO:<%s>" % USER)
s.cmd("VRFY x"); s.cmd("HELP"); s.cmd("NOOP")
r = s.cmd("DATA"); check("misc", "VRFY/HELP/NOOP don't disturb the transaction (RFC 5321 4.1.4)", code(r) == "354", r)
s.send(".\r\n"); s.reply()
r = s.cmd("QUIT"); check("misc", "QUIT -> 221 (RFC 5321 4.1.1.10)", code(r) == "221", r)
check("misc", "connection closed after QUIT (RFC 5321 4.1.1.10)", s.silent(2) is True and _closed(s), "")
s.close()
def _closed(s):
s.sock.settimeout(2)
try: return s.sock.recv(1) == b""
except Exception: return True
# ---------------------------------------------------------------- STARTTLS
def t_starttls():
s = S(); s.ehlo()
r = s.cmd("STARTTLS now")
check("starttls", "STARTTLS with a parameter -> 501 (RFC 3207 4)", code(r) == "501", r)
s.cmd("MAIL FROM:<before@client.test>")
s.starttls()
check("starttls", "TLS negotiated after 220 (RFC 3207 4)", s.sock.version() in ("TLSv1.2", "TLSv1.3"), s.sock.version())
r = s.cmd("RCPT TO:<%s>" % USER)
check("starttls", "pre-TLS state discarded after handshake (RFC 3207 4.2)", code(r) == "503", r)
r = s.ehlo(); kw = [l[4:].split(" ")[0].upper() for l in r[1:]]
check("starttls", "STARTTLS not offered again once encrypted (RFC 3207 4.2)", "STARTTLS" not in kw, r)
check("starttls", "AUTH offered once encrypted (RFC 4954)", "AUTH" in kw, r)
r = s.cmd("STARTTLS")
check("starttls", "second STARTTLS -> 503 (RFC 3207 4)", code(r) == "503", r, "SHOULD")
before = inbox_files()
r, msg = deliver(s, b"Subject: over tls\r\n\r\nbody\r\n.\r\n")
check("starttls", "message accepted over STARTTLS", code(r) == "250", r)
check("starttls", "Received header says 'with ESMTPS' (RFC 3848)", msg is not None and b"with ESMTPS" in msg[:800], (msg or b"")[:300])
s.close()
# command injection (CVE-2011-0411 class)
s = S(); s.ehlo()
s.send("STARTTLS\r\nMAIL FROM:<injected@evil.example>\r\nRCPT TO:<%s>\r\n" % USER)
r = s.reply()
left = s.buf
s.sock = tls_ctx().wrap_socket(s.sock, server_hostname=LOCAL); s.buf = b""
quiet = s.silent(1.0)
s.ehlo()
r2 = s.cmd("RCPT TO:<%s>" % USER)
check("starttls", "plain-text commands pipelined after STARTTLS are discarded (RFC 3207 4, CVE-2011-0411)",
code(r) == "220" and not left and quiet and code(r2) == "503", (r, left, quiet, r2))
s.close()
# large body over TLS (many full 16KB TLS records)
s = S(); s.ehlo(); s.starttls(); s.ehlo()
lines = ["Line %06d %s" % (i, "y" * 70) for i in range(6000)]
body = ("Subject: big tls\r\n\r\n" + "\r\n".join(lines) + "\r\n.\r\n").encode()
t0 = time.time(); r, msg = deliver(s, body)
ok = code(r) == "250" and msg is not None and all(l.encode() in msg for l in (lines[0], lines[2999], lines[-1]))
check("starttls", "~500KB message over TLS arrives complete (%.1fs)" % (time.time() - t0), ok, r)
s.close()
def t_implicit():
s = S(IMPLICIT, implicit=True)
check("implicit-tls", "greeting over implicit TLS (RFC 8314 3.3)", s.greeting[-1].startswith("220"), s.greeting)
r = s.ehlo(); kw = [l[4:].split(" ")[0].upper() for l in r[1:]]
check("implicit-tls", "no STARTTLS offered on an already-TLS port (RFC 3207 4.2)", "STARTTLS" not in kw, r)
check("implicit-tls", "AUTH offered on the TLS port", "AUTH" in kw, r)
r = s.cmd("AUTH PLAIN " + b64("\0%s\0%s" % (USER, PASSWORD)))
check("implicit-tls", "AUTH PLAIN succeeds on the TLS port", code(r) == "235", r)
s.close()
# ---------------------------------------------------------------- AUTH
def t_auth():
s = S()
r = s.cmd("AUTH PLAIN " + b64("\0%s\0%s" % (USER, PASSWORD)))
check("auth", "AUTH before EHLO -> 503 (RFC 4954 4)", code(r) == "503", r)
s.ehlo()
r = s.cmd("AUTH LOGIN")
check("auth", "AUTH before TLS refused -> 538 5.7.11 (RFC 4954 6)", code(r) == "538", r, "SHOULD")
s.close()
s = S(); s.ehlo(); s.starttls(); s.ehlo()
r = s.cmd("AUTH CRAM-MD5")
check("auth", "unsupported mechanism -> 504 (RFC 4954 6)", code(r) == "504", r)
r = s.cmd("AUTH")
check("auth", "AUTH without mechanism -> 501", code(r) == "501", r)
r = s.cmd("AUTH PLAIN " + b64("\0%s\0wrong" % USER))
check("auth", "bad password -> 535 5.7.8 (RFC 4954 6)", code(r) == "535" and " 5.7.8" in r[-1], r)
r = s.cmd("NOOP")
check("auth", "session usable after failed AUTH", code(r) == "250", r)
r = s.cmd("AUTH LOGIN"); r2 = s.cmd("*")
check("auth", "'*' cancels the exchange -> 501 (RFC 4954 4)", code(r) == "334" and code(r2) == "501", (r, r2))
r = s.cmd("AUTH LOGIN"); r2 = s.cmd("!!!not base64!!!")
check("auth", "invalid base64 -> 501 5.5.2 (RFC 4954 4)", code(r2) == "501", (r, r2))
r = s.cmd("AUTH PLAIN"); r2 = s.cmd(b64("\0%s\0%s" % (USER, PASSWORD)))
check("auth", "AUTH PLAIN without initial response: 334 then credentials -> 235 (RFC 4616, RFC 4954 4)",
r[-1].startswith("334") and code(r2) == "235", (r, r2))
r = s.cmd("AUTH PLAIN " + b64("\0%s\0%s" % (USER, PASSWORD)))
check("auth", "AUTH after successful AUTH -> 503 (RFC 4954 4)", code(r) == "503", r)
s.cmd("MAIL FROM:<%s>" % USER)
r = s.cmd("RCPT TO:<someone@elsewhere.example>")
check("auth", "authenticated client may relay (RFC 4954, RFC 6409)", code(r) == "250", r)
s.cmd("RSET")
s.close()
s = S(); s.ehlo(); s.starttls(); s.ehlo()
r = s.cmd("AUTH LOGIN"); r2 = s.cmd(b64(USER)); r3 = s.cmd(b64(PASSWORD))
check("auth", "AUTH LOGIN two-step -> 334, 334, 235", r[-1].startswith("334") and r2[-1].startswith("334") and code(r3) == "235", (r, r2, r3))
s.close()
s = S(); s.ehlo(); s.starttls(); s.ehlo()
r = s.cmd("AUTH PLAIN " + b64("someoneelse@mail.test\0%s\0%s" % (USER, PASSWORD)))
check("auth", "PLAIN authzid differing from authcid refused -> 535 (RFC 4616 2)", code(r) in ("535", "501"), r)
s.cmd("MAIL FROM:<a@client.test>")
r = s.cmd("AUTH PLAIN " + b64("\0%s\0%s" % (USER, PASSWORD)))
check("auth", "AUTH during a mail transaction -> 503 (RFC 4954 4)", code(r) == "503", r)
s.close()
s = S(); s.ehlo(); s.starttls(); s.ehlo()
s.cmd("AUTH PLAIN " + b64("\0%s\0%s" % (USER, PASSWORD)))
r, msg = deliver(s, b"Subject: authenticated\r\n\r\nbody\r\n.\r\n", frm=USER)
check("auth", "Received header says 'with ESMTPSA' when authenticated over TLS (RFC 3848)", msg is not None and b"with ESMTPSA" in msg[:800], (msg or b"")[:300])
s.close()
# ---------------------------------------------------------------- robustness
def t_robust():
payloads = ["MAIL FROM:<", "RCPT TO:<", "MAIL FROM:<@>", "RCPT TO:<@@@>", "HELO " + "a" * 3000,
"AUTH LOGIN " + "=" * 40, "MAIL FROM:<" + "a" * 5000 + "@x>", "\x00\x01\x02", "VRFY"]
for p in payloads:
try:
s = S(); s.ehlo()
if p.startswith("RCPT"): s.cmd("MAIL FROM:<a@client.test>")
s.cmd(p); s.close()
except Exception:
pass
try:
s = S(); r = s.cmd("NOOP"); alive = code(r) == "250"; s.close()
except Exception as e:
alive = False
check("robustness", "server survives malformed input (%d payloads)" % len(payloads), alive, "server stopped answering")
errors = []
def worker(n):
try:
k = S(); k.ehlo("c%d.test" % n)
k.cmd("MAIL FROM:<c%d@client.test>" % n); k.cmd("RCPT TO:<%s>" % USER); k.cmd("DATA")
k.send(("Subject: burst %d\r\n\r\n" % n + "line\r\n" * 500 + ".\r\n").encode())
r = k.reply(timeout=20)
if code(r) != "250": errors.append((n, r))
k.cmd("QUIT"); k.close()
except Exception as e:
errors.append((n, repr(e)))
ts = [threading.Thread(target=worker, args=(n,)) for n in range(40)]
[t.start() for t in ts]; [t.join(40) for t in ts]
check("robustness", "40 concurrent deliveries all succeed", not errors, errors[:3])
for fn in (t_greeting, t_parsing, t_ehlo, t_enhanced, t_sequence, t_mail, t_rcpt, t_data, t_split_crlf, t_size,
t_smuggling, t_pipelining, t_misc, t_starttls, t_implicit, t_auth, t_robust):
run(fn.__name__[2:], fn)
total = len(results); passed = sum(r["ok"] for r in results)
print("\n%d/%d checks passed" % (passed, total))
if JSON_OUT:
json.dump(results, open(JSON_OUT, "w"), indent=1)
sys.exit(0 if passed == total else 1)