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
139 lines
5.1 KiB
C++
139 lines
5.1 KiB
C++
#ifndef __SMTPServer_h__
|
|
# define __SMTPServer_h__
|
|
|
|
# include <string>
|
|
# include <vector>
|
|
# include <map>
|
|
# include <filesystem>
|
|
# include "EPoll.h"
|
|
# include "TCPServer.h"
|
|
# include "TLSInfo.h"
|
|
# include "SMTPSession.h"
|
|
# include "MailFileSystem.h"
|
|
# include "__SMTP_AUTH.h"
|
|
# include "__SMTP_DATA.h"
|
|
# include "__SMTP_EHLO.h"
|
|
# include "__SMTP_EXPN.h"
|
|
# include "__SMTP_HELO.h"
|
|
# include "__SMTP_HELP.h"
|
|
# include "__SMTP_MAIL.h"
|
|
# include "__SMTP_NOOP.h"
|
|
# include "__SMTP_QUIT.h"
|
|
# include "__SMTP_RCPT.h"
|
|
# include "__SMTP_RSET.h"
|
|
# include "__SMTP_STARTTLS.h"
|
|
# include "__SMTP_VRFY.h"
|
|
# include "INotify.h"
|
|
# include "SendMail.h"
|
|
# include "DKIMSigner.h"
|
|
# include "SpamAssassinFilter.h"
|
|
namespace mail {
|
|
|
|
class SMTPServer : public core::TCPServer, public core::INotify {
|
|
|
|
public:
|
|
// watchQueue controls whether this instance watches the mail
|
|
// queue directory and relays/delivers what lands in it - true by
|
|
// default for the ordinary single-listener case. Running a
|
|
// second SMTPServer for a submission/TLS port alongside the
|
|
// plaintext one needs watchQueue=false on exactly one of the two:
|
|
// each SMTPServer's own INotify watch is independent, so two
|
|
// watchers on the same directory would each fire inCreate() for
|
|
// every queued message, delivering it twice.
|
|
// dkimSigners is optional (nullptr = outbound mail goes out
|
|
// unsigned for every domain) and not owned - passed straight
|
|
// through to every SendMail this instance's inCreate() constructs
|
|
// for outbound relay, which picks the entry matching each
|
|
// individual message's own sender domain (see SendMail's own doc
|
|
// comment).
|
|
SMTPServer(core::EPoll &ePoll, std::string hostName, MailFileSystem &mailFileSystem,
|
|
core::IPAddress ipAddress, core::TLSInfo *tlsInfo, bool watchQueue = true,
|
|
std::map<std::string, DKIMSigner*> *dkimSigners = nullptr);
|
|
|
|
MailFileSystem &mailFileSystem;
|
|
std::string hostName;
|
|
core::EPoll &ePoll;
|
|
std::map<std::string, DKIMSigner*> *dkimSigners;
|
|
|
|
// Advertised via EHLO's "250-SIZE <n>" and enforced by __SMTP_DATA
|
|
// while accumulating a message body - RFC 1870. 25MB, matching
|
|
// the limit most real providers (e.g. Gmail) use.
|
|
static const size_t maxMessageSize = 25 * 1024 * 1024;
|
|
|
|
// RFC 5321 4.5.3.1.8 requires accepting at least 100 recipients per
|
|
// transaction; past this many, RCPT gets 452 4.5.3 and the client
|
|
// sends the rest in another transaction.
|
|
static const size_t maxRecipients = 1000;
|
|
|
|
SMTPSession * getSocketAccept(core::EPoll &ePoll) override;
|
|
void sessionErrorHandler(std::string errorString, std::stringstream &out);
|
|
|
|
///
|
|
/// When true (the default) and the session can be encrypted (it is
|
|
/// already, or STARTTLS is available), AUTH is offered and accepted
|
|
/// only once the session is encrypted, so mailbox passwords never
|
|
/// cross the network in clear (RFC 4954 4 and 14). With no TLS
|
|
/// certificate loaded at all, AUTH stays available in clear rather
|
|
/// than locking mail clients out.
|
|
///
|
|
|
|
bool requireTLSForAuth = true;
|
|
|
|
bool authAllowed(SMTPSession &session) {
|
|
return session.isTLS() || (!startTLSContext && !ctx) || !requireTLSForAuth;
|
|
}
|
|
|
|
///
|
|
/// True if `domain` (lower case) is one this server holds mailboxes
|
|
/// for - i.e. a domain directory exists under the mail path.
|
|
///
|
|
|
|
bool isLocalDomain(const std::string &domain);
|
|
|
|
///
|
|
/// Where mail for the bare "postmaster" address goes (RFC 5321 4.5.1:
|
|
/// it MUST be accepted, with or without a domain). postmaster@ the
|
|
/// server's own host name if that mailbox or alias exists, else the
|
|
/// same for each parent domain (mail.barant.com, then barant.com).
|
|
/// Empty if none exists anywhere.
|
|
///
|
|
|
|
std::string postmasterAddress();
|
|
|
|
protected:
|
|
void inCreate(coreutils::ZString &name);
|
|
|
|
private:
|
|
__SMTP_AUTH _smtp_auth;
|
|
__SMTP_DATA _smtp_data;
|
|
__SMTP_EHLO _smtp_ehlo;
|
|
__SMTP_EXPN _smtp_expn;
|
|
__SMTP_HELO _smtp_helo;
|
|
__SMTP_HELP _smtp_help;
|
|
__SMTP_MAIL _smtp_mail;
|
|
__SMTP_NOOP _smtp_noop;
|
|
__SMTP_QUIT _smtp_quit;
|
|
__SMTP_RCPT _smtp_rcpt;
|
|
__SMTP_RSET _smtp_rset;
|
|
__SMTP_STARTTLS _smtp_starttls;
|
|
__SMTP_VRFY _smtp_vrfy;
|
|
int wd;
|
|
|
|
void processExisting();
|
|
|
|
// Writes one already-scanned message into one mailbox's Inbox
|
|
// or Spam folder - factored out of inCreate() so an alias
|
|
// (MailFileSystem::ifAliasExists()/getAliasMailboxes()) can
|
|
// deliver the same scanned copy to each of its target mailboxes,
|
|
// not just the single recipient a plain local delivery has.
|
|
// `sender` is the envelope reverse-path, recorded as Return-Path:
|
|
// (RFC 5321 4.4 - the final delivery server MUST add it).
|
|
void deliverToMailbox(coreutils::ZString &mailbox, coreutils::ZString &messageId,
|
|
SpamAssassinFilter::Result &scan, const std::string &sender);
|
|
|
|
};
|
|
|
|
}
|
|
|
|
#endif
|