#!/usr/bin/env python3 """ SMTP server conformance + robustness suite for BARANTMail. Usage: smtp_conformance.py [--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.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:") 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- (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:", "RCPT TO:<%s>" % USER, "RSET", "RCPT TO:<%s>" % USER, "FROB", "VRFY brad", "HELP", "MAIL FROM: 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:") 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:") r = s.cmd("MAIL FROM:") 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:"); 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:") 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:") check("mail", "MAIL FROM: -> 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: 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: 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: BODY=7BIT") check("mail", "BODY=7BIT accepted (RFC 6152 3)", code(r) == "250", r); s.cmd("RSET") r = s.cmd("MAIL FROM: 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:") 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:") 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:") check("rcpt", "domain matched case-insensitively (RFC 5321 2.4)", code(r) == "250", r) r = s.cmd("RCPT TO:") check("rcpt", "local-part matched case-insensitively for existing mailbox (RFC 5321 2.4)", code(r) == "250", r, "SHOULD") r = s.cmd("RCPT TO:") 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:") 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:") check("rcpt", " with no domain accepted (RFC 5321 4.5.1 MUST)", code(r) == "250", r) r = s.cmd("RCPT TO:") 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:") 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:") 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:"); 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: \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 ' 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: "), 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:"); 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:"); 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 . # ends DATA (RFC 5321 4.1.1.4 / 2.3.8); bare-LF / bare-CR variants must not. variants = {".": b"\n.\n", ".": b"\n.\r\n", ".": b"\r\n.\n", ".": b"\r.\r", ".": b"\r\n.\r"} for name, term in variants.items(): s = S(); s.ehlo() before = inbox_files() s.cmd("MAIL FROM:"); s.cmd("RCPT TO:<%s>" % USER); s.cmd("DATA") body = (b"Subject: carrier\r\n\r\nhello" + term + b"MAIL FROM:\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:\r\nRCPT TO:<%s>\r\nRCPT TO:\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:"); 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:") 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:\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:") 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:") 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:") 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:" % 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)