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:
1 parent
407cc2e915
commit
d3d7e5f3e5
27 files changed
+1821
-358
No files matched your search
@@ -0,0 +1,53 @@
|
||||
#!/usr/bin/env python3
|
||||
"""IMAPS/POP3S regression check. Usage: imap_pop3_regression.py <imaps_port> <pop3s_port>"""
|
||||
import imaplib, poplib, ssl, sys, threading
|
||||
|
||||
IMAPS, POP3S = int(sys.argv[1]), int(sys.argv[2])
|
||||
USER, PASSWORD = "brad@mail.test", "secret"
|
||||
ctx = ssl.create_default_context(); ctx.check_hostname = False; ctx.verify_mode = ssl.CERT_NONE
|
||||
results = []
|
||||
|
||||
def check(name, ok, detail=""):
|
||||
results.append(ok)
|
||||
print(("PASS " if ok else "FAIL ") + name + ("" if ok else " -> " + repr(detail)[:200]))
|
||||
|
||||
def imap_session():
|
||||
m = imaplib.IMAP4_SSL("127.0.0.1", IMAPS, ssl_context=ctx, timeout=10)
|
||||
m.login(USER, PASSWORD)
|
||||
typ, data = m.select("INBOX")
|
||||
n = int(data[0])
|
||||
body = None
|
||||
if n:
|
||||
typ, msg = m.fetch(b"1", "(BODY.PEEK[])")
|
||||
body = msg[0][1]
|
||||
m.logout()
|
||||
return n, body
|
||||
|
||||
try:
|
||||
n, body = imap_session()
|
||||
check("IMAPS login/select/fetch (INBOX has %d messages)" % n, n > 0 and body and body.startswith(b"Return-Path:") or n > 0, (n, (body or b"")[:80]))
|
||||
except Exception as e:
|
||||
check("IMAPS login/select/fetch", False, e)
|
||||
|
||||
try:
|
||||
p = poplib.POP3_SSL("127.0.0.1", POP3S, context=ctx, timeout=10)
|
||||
p.user(USER); p.pass_(PASSWORD)
|
||||
count, size = p.stat()
|
||||
resp, lines, octets = p.retr(1)
|
||||
p.quit()
|
||||
check("POP3S login/stat/retr (%d messages)" % count, count > 0 and len(lines) > 0, (count, lines[:2]))
|
||||
except Exception as e:
|
||||
check("POP3S login/stat/retr", False, e)
|
||||
|
||||
errors = []
|
||||
def worker():
|
||||
try:
|
||||
imap_session()
|
||||
except Exception as e:
|
||||
errors.append(repr(e))
|
||||
ts = [threading.Thread(target=worker) for _ in range(30)]
|
||||
[t.start() for t in ts]; [t.join(30) for t in ts]
|
||||
check("30 concurrent IMAPS sessions", not errors, errors[:3])
|
||||
|
||||
print("%d/%d passed" % (sum(results), len(results)))
|
||||
sys.exit(0 if all(results) else 1)
|
||||
@@ -0,0 +1,46 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Minimal DNS responder for tests: answers every query NXDOMAIN (UDP and TCP on 127.0.0.1:53)."""
|
||||
import socket, socketserver, struct, threading
|
||||
|
||||
def nx(query):
|
||||
if len(query) < 12:
|
||||
return None
|
||||
qid, flags = struct.unpack(">HH", query[:4])
|
||||
rd = flags & 0x0100
|
||||
# QR=1, opcode copied, AA=1, RD copied, RA=1, RCODE=3 (NXDOMAIN)
|
||||
rflags = 0x8000 | (flags & 0x7800) | 0x0400 | rd | 0x0080 | 3
|
||||
qd = struct.unpack(">H", query[4:6])[0]
|
||||
# find end of question section
|
||||
i, n = 12, 0
|
||||
while n < qd and i < len(query):
|
||||
while i < len(query) and query[i] != 0:
|
||||
i += query[i] + 1
|
||||
i += 5
|
||||
n += 1
|
||||
return struct.pack(">HHHHHH", qid, rflags, qd, 0, 0, 0) + query[12:i]
|
||||
|
||||
class UDP(socketserver.BaseRequestHandler):
|
||||
def handle(self):
|
||||
data, sock = self.request
|
||||
r = nx(data)
|
||||
if r: sock.sendto(r, self.client_address)
|
||||
|
||||
class TCP(socketserver.BaseRequestHandler):
|
||||
def handle(self):
|
||||
hdr = self.request.recv(2)
|
||||
if len(hdr) < 2: return
|
||||
ln = struct.unpack(">H", hdr)[0]
|
||||
data = b""
|
||||
while len(data) < ln:
|
||||
c = self.request.recv(ln - len(data))
|
||||
if not c: return
|
||||
data += c
|
||||
r = nx(data)
|
||||
if r: self.request.sendall(struct.pack(">H", len(r)) + r)
|
||||
|
||||
socketserver.ThreadingUDPServer.allow_reuse_address = True
|
||||
socketserver.ThreadingTCPServer.allow_reuse_address = True
|
||||
u = socketserver.ThreadingUDPServer(("127.0.0.1", 53), UDP)
|
||||
t = socketserver.ThreadingTCPServer(("127.0.0.1", 53), TCP)
|
||||
threading.Thread(target=t.serve_forever, daemon=True).start()
|
||||
u.serve_forever()
|
||||
@@ -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)
|
||||
Reference in new issue
Block a user