1909 lines
62 KiB
Python
1909 lines
62 KiB
Python
# Copyright (c) Twisted Matrix Laboratories.
|
|
# See LICENSE for details.
|
|
|
|
"""
|
|
Test cases for twisted.mail.smtp module.
|
|
"""
|
|
|
|
|
|
import base64
|
|
import inspect
|
|
import re
|
|
from io import BytesIO
|
|
from typing import Any, List, Optional, Tuple, Type
|
|
|
|
from zope.interface import directlyProvides, implementer
|
|
|
|
import twisted.cred.checkers
|
|
import twisted.cred.credentials
|
|
import twisted.cred.error
|
|
import twisted.cred.portal
|
|
from twisted import cred
|
|
from twisted.cred.checkers import AllowAnonymousAccess, ICredentialsChecker
|
|
from twisted.cred.credentials import IAnonymous
|
|
from twisted.cred.error import UnauthorizedLogin
|
|
from twisted.cred.portal import IRealm, Portal
|
|
from twisted.internet import address, defer, error, interfaces, protocol, reactor, task
|
|
from twisted.internet.testing import MemoryReactor, StringTransport
|
|
from twisted.mail import smtp
|
|
from twisted.mail._cred import LOGINCredentials
|
|
from twisted.protocols import basic, loopback
|
|
from twisted.python.util import LineLog
|
|
from twisted.trial.unittest import TestCase
|
|
|
|
sslSkip: Optional[str]
|
|
try:
|
|
from twisted.test.ssl_helpers import ClientTLSContext, ServerTLSContext
|
|
except ImportError:
|
|
sslSkip = "OpenSSL not present"
|
|
else:
|
|
sslSkip = None
|
|
|
|
|
|
if not interfaces.IReactorSSL.providedBy(reactor):
|
|
sslSkip = "Reactor doesn't support SSL"
|
|
|
|
|
|
def spameater(*spam, **eggs):
|
|
return None
|
|
|
|
|
|
@implementer(smtp.IMessage)
|
|
class BrokenMessage:
|
|
"""
|
|
L{BrokenMessage} is an L{IMessage} which raises an unexpected exception
|
|
from its C{eomReceived} method. This is useful for creating a server which
|
|
can be used to test client retry behavior.
|
|
"""
|
|
|
|
def __init__(self, user):
|
|
pass
|
|
|
|
def lineReceived(self, line):
|
|
pass
|
|
|
|
def eomReceived(self):
|
|
raise RuntimeError("Some problem, delivery is failing.")
|
|
|
|
def connectionLost(self):
|
|
pass
|
|
|
|
|
|
class DummyMessage:
|
|
"""
|
|
L{BrokenMessage} is an L{IMessage} which saves the message delivered to it
|
|
to its domain object.
|
|
|
|
@ivar domain: A L{DummyDomain} which will be used to store the message once
|
|
it is received.
|
|
"""
|
|
|
|
def __init__(self, domain, user):
|
|
self.domain = domain
|
|
self.user = user
|
|
self.buffer = []
|
|
|
|
def lineReceived(self, line):
|
|
# Throw away the generated Received: header
|
|
if not re.match(rb"Received: From yyy.com \(\[.*\]\) by localhost;", line):
|
|
self.buffer.append(line)
|
|
|
|
def eomReceived(self):
|
|
message = b"\n".join(self.buffer) + b"\n"
|
|
self.domain.messages[self.user.dest.local].append(message)
|
|
deferred = defer.Deferred()
|
|
deferred.callback(b"saved")
|
|
return deferred
|
|
|
|
|
|
class DummyDomain:
|
|
"""
|
|
L{DummyDomain} is an L{IDomain} which keeps track of messages delivered to
|
|
it in memory.
|
|
"""
|
|
|
|
def __init__(self, names):
|
|
self.messages = {}
|
|
for name in names:
|
|
self.messages[name] = []
|
|
|
|
def exists(self, user):
|
|
if user.dest.local in self.messages:
|
|
return defer.succeed(lambda: DummyMessage(self, user))
|
|
return defer.fail(smtp.SMTPBadRcpt(user))
|
|
|
|
|
|
mail = b"""\
|
|
Subject: hello
|
|
|
|
Goodbye
|
|
"""
|
|
|
|
|
|
class MyClient:
|
|
def __init__(self, messageInfo=None):
|
|
if messageInfo is None:
|
|
messageInfo = ("moshez@foo.bar", ["moshez@foo.bar"], BytesIO(mail))
|
|
self._sender = messageInfo[0]
|
|
self._recipient = messageInfo[1]
|
|
self._data = messageInfo[2]
|
|
|
|
def getMailFrom(self):
|
|
return self._sender
|
|
|
|
def getMailTo(self):
|
|
return self._recipient
|
|
|
|
def getMailData(self):
|
|
return self._data
|
|
|
|
def sendError(self, exc):
|
|
self._error = exc
|
|
|
|
def sentMail(self, code, resp, numOk, addresses, log):
|
|
# Prevent another mail from being sent.
|
|
self._sender = None
|
|
self._recipient = None
|
|
self._data = None
|
|
|
|
|
|
class MySMTPClient(MyClient, smtp.SMTPClient):
|
|
def __init__(self, messageInfo=None):
|
|
smtp.SMTPClient.__init__(self, b"foo.baz")
|
|
MyClient.__init__(self, messageInfo)
|
|
|
|
|
|
class MyESMTPClient(MyClient, smtp.ESMTPClient):
|
|
def __init__(self, secret=b"", contextFactory=None):
|
|
smtp.ESMTPClient.__init__(self, secret, contextFactory, b"foo.baz")
|
|
MyClient.__init__(self)
|
|
|
|
|
|
class LoopbackMixin:
|
|
def loopback(self, server, client):
|
|
return loopback.loopbackTCP(server, client)
|
|
|
|
|
|
class FakeSMTPServer(basic.LineReceiver):
|
|
clientData = [
|
|
b"220 hello",
|
|
b"250 nice to meet you",
|
|
b"250 great",
|
|
b"250 great",
|
|
b"354 go on, lad",
|
|
]
|
|
|
|
def connectionMade(self):
|
|
self.buffer = []
|
|
self.clientData = self.clientData[:]
|
|
self.clientData.reverse()
|
|
self.sendLine(self.clientData.pop())
|
|
|
|
def lineReceived(self, line):
|
|
self.buffer.append(line)
|
|
if line == b"QUIT":
|
|
self.transport.write(b"221 see ya around\r\n")
|
|
self.transport.loseConnection()
|
|
elif line == b".":
|
|
self.transport.write(b"250 gotcha\r\n")
|
|
elif line == b"RSET":
|
|
self.transport.loseConnection()
|
|
|
|
if self.clientData:
|
|
self.sendLine(self.clientData.pop())
|
|
|
|
|
|
class SMTPClientTests(TestCase, LoopbackMixin):
|
|
"""
|
|
Tests for L{smtp.SMTPClient}.
|
|
"""
|
|
|
|
def test_timeoutConnection(self):
|
|
"""
|
|
L{smtp.SMTPClient.timeoutConnection} calls the C{sendError} hook with a
|
|
fatal L{SMTPTimeoutError} with the current line log.
|
|
"""
|
|
errors = []
|
|
client = MySMTPClient()
|
|
client.sendError = errors.append
|
|
client.makeConnection(StringTransport())
|
|
client.lineReceived(b"220 hello")
|
|
client.timeoutConnection()
|
|
self.assertIsInstance(errors[0], smtp.SMTPTimeoutError)
|
|
self.assertTrue(errors[0].isFatal)
|
|
self.assertEqual(
|
|
bytes(errors[0]),
|
|
b"Timeout waiting for SMTP server response\n"
|
|
b"<<< 220 hello\n"
|
|
b">>> HELO foo.baz\n",
|
|
)
|
|
|
|
expected_output = [
|
|
b"HELO foo.baz",
|
|
b"MAIL FROM:<moshez@foo.bar>",
|
|
b"RCPT TO:<moshez@foo.bar>",
|
|
b"DATA",
|
|
b"Subject: hello",
|
|
b"",
|
|
b"Goodbye",
|
|
b".",
|
|
b"RSET",
|
|
]
|
|
|
|
def test_messages(self):
|
|
"""
|
|
L{smtp.SMTPClient} sends I{HELO}, I{MAIL FROM}, I{RCPT TO}, and I{DATA}
|
|
commands based on the return values of its C{getMailFrom},
|
|
C{getMailTo}, and C{getMailData} methods.
|
|
"""
|
|
client = MySMTPClient()
|
|
server = FakeSMTPServer()
|
|
d = self.loopback(server, client)
|
|
d.addCallback(lambda x: self.assertEqual(server.buffer, self.expected_output))
|
|
return d
|
|
|
|
def test_transferError(self):
|
|
"""
|
|
If there is an error while producing the message body to the
|
|
connection, the C{sendError} callback is invoked.
|
|
"""
|
|
client = MySMTPClient(
|
|
("alice@example.com", ["bob@example.com"], BytesIO(b"foo"))
|
|
)
|
|
transport = StringTransport()
|
|
client.makeConnection(transport)
|
|
client.dataReceived(
|
|
b"220 Ok\r\n" # Greeting
|
|
b"250 Ok\r\n" # EHLO response
|
|
b"250 Ok\r\n" # MAIL FROM response
|
|
b"250 Ok\r\n" # RCPT TO response
|
|
b"354 Ok\r\n" # DATA response
|
|
)
|
|
|
|
# Sanity check - a pull producer should be registered now.
|
|
self.assertNotIdentical(transport.producer, None)
|
|
self.assertFalse(transport.streaming)
|
|
|
|
# Now stop the producer prematurely, meaning the message was not sent.
|
|
transport.producer.stopProducing()
|
|
|
|
# The sendError hook should have been invoked as a result.
|
|
self.assertIsInstance(client._error, Exception)
|
|
|
|
def test_sendFatalError(self):
|
|
"""
|
|
If L{smtp.SMTPClient.sendError} is called with an L{SMTPClientError}
|
|
which is fatal, it disconnects its transport without writing anything
|
|
more to it.
|
|
"""
|
|
client = smtp.SMTPClient(None)
|
|
transport = StringTransport()
|
|
client.makeConnection(transport)
|
|
client.sendError(smtp.SMTPClientError(123, "foo", isFatal=True))
|
|
self.assertEqual(transport.value(), b"")
|
|
self.assertTrue(transport.disconnecting)
|
|
|
|
def test_sendNonFatalError(self):
|
|
"""
|
|
If L{smtp.SMTPClient.sendError} is called with an L{SMTPClientError}
|
|
which is not fatal, it sends C{"QUIT"} and waits for the server to
|
|
close the connection.
|
|
"""
|
|
client = smtp.SMTPClient(None)
|
|
transport = StringTransport()
|
|
client.makeConnection(transport)
|
|
client.sendError(smtp.SMTPClientError(123, "foo", isFatal=False))
|
|
self.assertEqual(transport.value(), b"QUIT\r\n")
|
|
self.assertFalse(transport.disconnecting)
|
|
|
|
def test_sendOtherError(self):
|
|
"""
|
|
If L{smtp.SMTPClient.sendError} is called with an exception which is
|
|
not an L{SMTPClientError}, it disconnects its transport without
|
|
writing anything more to it.
|
|
"""
|
|
client = smtp.SMTPClient(None)
|
|
transport = StringTransport()
|
|
client.makeConnection(transport)
|
|
client.sendError(Exception("foo"))
|
|
self.assertEqual(transport.value(), b"")
|
|
self.assertTrue(transport.disconnecting)
|
|
|
|
|
|
class DummySMTPMessage:
|
|
def __init__(self, protocol, users):
|
|
self.protocol = protocol
|
|
self.users = users
|
|
self.buffer = []
|
|
|
|
def lineReceived(self, line):
|
|
self.buffer.append(line)
|
|
|
|
def eomReceived(self):
|
|
message = b"\n".join(self.buffer) + b"\n"
|
|
helo, origin = self.users[0].helo[0], bytes(self.users[0].orig)
|
|
recipients = []
|
|
for user in self.users:
|
|
recipients.append(bytes(user))
|
|
self.protocol.message[tuple(recipients)] = (helo, origin, recipients, message)
|
|
return defer.succeed(b"saved")
|
|
|
|
|
|
class DummyProto:
|
|
def connectionMade(self):
|
|
self.dummyMixinBase.connectionMade(self)
|
|
self.message = {}
|
|
|
|
def receivedHeader(*spam):
|
|
return None
|
|
|
|
def validateTo(self, user):
|
|
self.delivery = SimpleDelivery(None)
|
|
return lambda: DummySMTPMessage(self, [user])
|
|
|
|
def validateFrom(self, helo, origin):
|
|
return origin
|
|
|
|
|
|
class DummySMTP(DummyProto, smtp.SMTP):
|
|
dummyMixinBase = smtp.SMTP
|
|
|
|
|
|
class DummyESMTP(DummyProto, smtp.ESMTP):
|
|
dummyMixinBase = smtp.ESMTP
|
|
|
|
|
|
class AnotherTestCase:
|
|
serverClass: Optional[Type[protocol.Protocol]] = None
|
|
clientClass: Optional[Type[smtp.SMTPClient]] = None
|
|
|
|
messages = [
|
|
(
|
|
b"foo.com",
|
|
b"moshez@foo.com",
|
|
[b"moshez@bar.com"],
|
|
b"moshez@foo.com",
|
|
[b"moshez@bar.com"],
|
|
b"""\
|
|
From: Moshe
|
|
To: Moshe
|
|
|
|
Hi,
|
|
how are you?
|
|
""",
|
|
),
|
|
(
|
|
b"foo.com",
|
|
b"tttt@rrr.com",
|
|
[b"uuu@ooo", b"yyy@eee"],
|
|
b"tttt@rrr.com",
|
|
[b"uuu@ooo", b"yyy@eee"],
|
|
b"""\
|
|
Subject: pass
|
|
|
|
..rrrr..
|
|
""",
|
|
),
|
|
(
|
|
b"foo.com",
|
|
b"@this,@is,@ignored:foo@bar.com",
|
|
[b"@ignore,@this,@too:bar@foo.com"],
|
|
b"foo@bar.com",
|
|
[b"bar@foo.com"],
|
|
b"""\
|
|
Subject: apa
|
|
To: foo
|
|
|
|
123
|
|
.
|
|
456
|
|
""",
|
|
),
|
|
]
|
|
|
|
data: List[Tuple[bytes, bytes, Any, Any]] = [
|
|
(b"", b"220.*\r\n$", None, None),
|
|
(b"HELO foo.com\r\n", b"250.*\r\n$", None, None),
|
|
(b"RSET\r\n", b"250.*\r\n$", None, None),
|
|
]
|
|
for helo_, from_, to_, realfrom, realto, msg in messages:
|
|
data.append((b"MAIL FROM:<" + from_ + b">\r\n", b"250.*\r\n", None, None))
|
|
for rcpt in to_:
|
|
data.append((b"RCPT TO:<" + rcpt + b">\r\n", b"250.*\r\n", None, None))
|
|
|
|
data.append(
|
|
(
|
|
b"DATA\r\n",
|
|
b"354.*\r\n",
|
|
msg,
|
|
(b"250.*\r\n", (helo_, realfrom, realto, msg)),
|
|
)
|
|
)
|
|
|
|
def test_buffer(self):
|
|
"""
|
|
Exercise a lot of the SMTP client code. This is a "shotgun" style unit
|
|
test. It does a lot of things and hopes that something will go really
|
|
wrong if it is going to go wrong. This test should be replaced with a
|
|
suite of nicer tests.
|
|
"""
|
|
transport = StringTransport()
|
|
a = self.serverClass()
|
|
|
|
class fooFactory:
|
|
domain = b"foo.com"
|
|
|
|
a.factory = fooFactory()
|
|
a.makeConnection(transport)
|
|
for send, expect, msg, msgexpect in self.data:
|
|
if send:
|
|
a.dataReceived(send)
|
|
data = transport.value()
|
|
transport.clear()
|
|
if not re.match(expect, data):
|
|
raise AssertionError(send, expect, data)
|
|
if data[:3] == b"354":
|
|
for line in msg.splitlines():
|
|
if line and line[0:1] == b".":
|
|
line = b"." + line
|
|
a.dataReceived(line + b"\r\n")
|
|
a.dataReceived(b".\r\n")
|
|
# Special case for DATA. Now we want a 250, and then
|
|
# we compare the messages
|
|
data = transport.value()
|
|
transport.clear()
|
|
resp, msgdata = msgexpect
|
|
if not re.match(resp, data):
|
|
raise AssertionError(resp, data)
|
|
for recip in msgdata[2]:
|
|
expected = list(msgdata[:])
|
|
expected[2] = [recip]
|
|
self.assertEqual(a.message[(recip,)], tuple(expected))
|
|
a.setTimeout(None)
|
|
|
|
|
|
class AnotherESMTPTests(AnotherTestCase, TestCase):
|
|
serverClass = DummyESMTP
|
|
clientClass = MyESMTPClient
|
|
|
|
|
|
class AnotherSMTPTests(AnotherTestCase, TestCase):
|
|
serverClass = DummySMTP
|
|
clientClass = MySMTPClient
|
|
|
|
|
|
@implementer(cred.checkers.ICredentialsChecker)
|
|
class DummyChecker:
|
|
users = {b"testuser": b"testpassword"}
|
|
|
|
credentialInterfaces = (
|
|
cred.credentials.IUsernamePassword,
|
|
cred.credentials.IUsernameHashedPassword,
|
|
)
|
|
|
|
def requestAvatarId(self, credentials):
|
|
return defer.maybeDeferred(
|
|
credentials.checkPassword, self.users[credentials.username]
|
|
).addCallback(self._cbCheck, credentials.username)
|
|
|
|
def _cbCheck(self, result, username):
|
|
if result:
|
|
return username
|
|
raise cred.error.UnauthorizedLogin()
|
|
|
|
|
|
@implementer(smtp.IMessageDelivery)
|
|
class SimpleDelivery:
|
|
"""
|
|
L{SimpleDelivery} is a message delivery factory with no interesting
|
|
behavior.
|
|
"""
|
|
|
|
def __init__(self, messageFactory):
|
|
self._messageFactory = messageFactory
|
|
|
|
def receivedHeader(self, helo, origin, recipients):
|
|
return None
|
|
|
|
def validateFrom(self, helo, origin):
|
|
return origin
|
|
|
|
def validateTo(self, user):
|
|
return lambda: self._messageFactory(user)
|
|
|
|
|
|
class DummyRealm:
|
|
def requestAvatar(self, avatarId, mind, *interfaces):
|
|
return smtp.IMessageDelivery, SimpleDelivery(None), lambda: None
|
|
|
|
|
|
class AuthTests(TestCase, LoopbackMixin):
|
|
def test_crammd5Auth(self):
|
|
"""
|
|
L{ESMTPClient} can authenticate using the I{CRAM-MD5} SASL mechanism.
|
|
|
|
@see: U{http://tools.ietf.org/html/rfc2195}
|
|
"""
|
|
realm = DummyRealm()
|
|
p = cred.portal.Portal(realm)
|
|
p.registerChecker(DummyChecker())
|
|
|
|
server = DummyESMTP({b"CRAM-MD5": cred.credentials.CramMD5Credentials})
|
|
server.portal = p
|
|
client = MyESMTPClient(b"testpassword")
|
|
|
|
cAuth = smtp.CramMD5ClientAuthenticator(b"testuser")
|
|
client.registerAuthenticator(cAuth)
|
|
|
|
d = self.loopback(server, client)
|
|
d.addCallback(lambda x: self.assertEqual(server.authenticated, 1))
|
|
return d
|
|
|
|
def test_loginAuth(self):
|
|
"""
|
|
L{ESMTPClient} can authenticate using the I{LOGIN} SASL mechanism.
|
|
|
|
@see: U{http://sepp.oetiker.ch/sasl-2.1.19-ds/draft-murchison-sasl-login-00.txt}
|
|
"""
|
|
realm = DummyRealm()
|
|
p = cred.portal.Portal(realm)
|
|
p.registerChecker(DummyChecker())
|
|
|
|
server = DummyESMTP({b"LOGIN": LOGINCredentials})
|
|
server.portal = p
|
|
client = MyESMTPClient(b"testpassword")
|
|
|
|
cAuth = smtp.LOGINAuthenticator(b"testuser")
|
|
client.registerAuthenticator(cAuth)
|
|
|
|
d = self.loopback(server, client)
|
|
d.addCallback(lambda x: self.assertTrue(server.authenticated))
|
|
return d
|
|
|
|
def test_loginAgainstWeirdServer(self):
|
|
"""
|
|
When communicating with a server which implements the I{LOGIN} SASL
|
|
mechanism using C{"Username:"} as the challenge (rather than C{"User
|
|
Name\\0"}), L{ESMTPClient} can still authenticate successfully using
|
|
the I{LOGIN} mechanism.
|
|
"""
|
|
realm = DummyRealm()
|
|
p = cred.portal.Portal(realm)
|
|
p.registerChecker(DummyChecker())
|
|
|
|
server = DummyESMTP({b"LOGIN": smtp.LOGINCredentials})
|
|
server.portal = p
|
|
|
|
client = MyESMTPClient(b"testpassword")
|
|
cAuth = smtp.LOGINAuthenticator(b"testuser")
|
|
client.registerAuthenticator(cAuth)
|
|
|
|
d = self.loopback(server, client)
|
|
d.addCallback(lambda x: self.assertTrue(server.authenticated))
|
|
return d
|
|
|
|
|
|
class SMTPHelperTests(TestCase):
|
|
def testMessageID(self):
|
|
d = {}
|
|
for i in range(1000):
|
|
m = smtp.messageid("testcase")
|
|
self.assertFalse(m in d)
|
|
d[m] = None
|
|
|
|
def testQuoteAddr(self):
|
|
cases = [
|
|
[b"user@host.name", b"<user@host.name>"],
|
|
[b'"User Name" <user@host.name>', b"<user@host.name>"],
|
|
[smtp.Address(b"someguy@someplace"), b"<someguy@someplace>"],
|
|
[b"", b"<>"],
|
|
[smtp.Address(b""), b"<>"],
|
|
]
|
|
|
|
for c, e in cases:
|
|
self.assertEqual(smtp.quoteaddr(c), e)
|
|
|
|
def testUser(self):
|
|
u = smtp.User(b"user@host", b"helo.host.name", None, None)
|
|
self.assertEqual(str(u), "user@host")
|
|
|
|
def testXtextEncoding(self):
|
|
cases = [
|
|
("Hello world", b"Hello+20world"),
|
|
("Hello+world", b"Hello+2Bworld"),
|
|
("\0\1\2\3\4\5", b"+00+01+02+03+04+05"),
|
|
("e=mc2@example.com", b"e+3Dmc2@example.com"),
|
|
]
|
|
|
|
for case, expected in cases:
|
|
self.assertEqual(smtp.xtext_encode(case), (expected, len(case)))
|
|
self.assertEqual(case.encode("xtext"), expected)
|
|
self.assertEqual(smtp.xtext_decode(expected), (case, len(expected)))
|
|
self.assertEqual(expected.decode("xtext"), case)
|
|
|
|
def test_encodeWithErrors(self):
|
|
"""
|
|
Specifying an error policy to C{unicode.encode} with the
|
|
I{xtext} codec should produce the same result as not
|
|
specifying the error policy.
|
|
"""
|
|
text = "Hello world"
|
|
self.assertEqual(
|
|
smtp.xtext_encode(text, "strict"), (text.encode("xtext"), len(text))
|
|
)
|
|
self.assertEqual(text.encode("xtext", "strict"), text.encode("xtext"))
|
|
|
|
def test_decodeWithErrors(self):
|
|
"""
|
|
Similar to L{test_encodeWithErrors}, but for C{bytes.decode}.
|
|
"""
|
|
bytes = b"Hello world"
|
|
self.assertEqual(
|
|
smtp.xtext_decode(bytes, "strict"), (bytes.decode("xtext"), len(bytes))
|
|
)
|
|
self.assertEqual(bytes.decode("xtext", "strict"), bytes.decode("xtext"))
|
|
|
|
|
|
class NoticeTLSClient(MyESMTPClient):
|
|
tls = False
|
|
|
|
def esmtpState_starttls(self, code, resp):
|
|
MyESMTPClient.esmtpState_starttls(self, code, resp)
|
|
self.tls = True
|
|
|
|
|
|
class TLSTests(TestCase, LoopbackMixin):
|
|
skip = sslSkip
|
|
|
|
def testTLS(self):
|
|
clientCTX = ClientTLSContext()
|
|
serverCTX = ServerTLSContext()
|
|
|
|
client = NoticeTLSClient(contextFactory=clientCTX)
|
|
server = DummyESMTP(contextFactory=serverCTX)
|
|
|
|
def check(ignored):
|
|
self.assertEqual(client.tls, True)
|
|
self.assertEqual(server.startedTLS, True)
|
|
|
|
return self.loopback(server, client).addCallback(check)
|
|
|
|
|
|
class EmptyLineTests(TestCase):
|
|
def test_emptyLineSyntaxError(self):
|
|
"""
|
|
If L{smtp.SMTP} receives an empty line, it responds with a 500 error
|
|
response code and a message about a syntax error.
|
|
"""
|
|
proto = smtp.SMTP()
|
|
transport = StringTransport()
|
|
proto.makeConnection(transport)
|
|
proto.lineReceived(b"")
|
|
proto.setTimeout(None)
|
|
|
|
out = transport.value().splitlines()
|
|
self.assertEqual(len(out), 2)
|
|
self.assertTrue(out[0].startswith(b"220"))
|
|
self.assertEqual(out[1], b"500 Error: bad syntax")
|
|
|
|
|
|
class TimeoutTests(TestCase, LoopbackMixin):
|
|
"""
|
|
Check that SMTP client factories correctly use the timeout.
|
|
"""
|
|
|
|
def _timeoutTest(self, onDone, clientFactory):
|
|
"""
|
|
Connect the clientFactory, and check the timeout on the request.
|
|
"""
|
|
clock = task.Clock()
|
|
client = clientFactory.buildProtocol(
|
|
address.IPv4Address("TCP", "example.net", 25)
|
|
)
|
|
client.callLater = clock.callLater
|
|
t = StringTransport()
|
|
client.makeConnection(t)
|
|
t.protocol = client
|
|
|
|
def check(ign):
|
|
self.assertEqual(clock.seconds(), 0.5)
|
|
|
|
d = self.assertFailure(onDone, smtp.SMTPTimeoutError).addCallback(check)
|
|
# The first call should not trigger the timeout
|
|
clock.advance(0.1)
|
|
# But this one should
|
|
clock.advance(0.4)
|
|
return d
|
|
|
|
def test_SMTPClientRecipientBytes(self):
|
|
"""
|
|
Test timeout for L{smtp.SMTPSenderFactory}: the response L{Deferred}
|
|
should be errback with a L{smtp.SMTPTimeoutError}.
|
|
"""
|
|
onDone = defer.Deferred()
|
|
clientFactory = smtp.SMTPSenderFactory(
|
|
"source@address",
|
|
b"recipient@address",
|
|
BytesIO(b"Message body"),
|
|
onDone,
|
|
retries=0,
|
|
timeout=0.5,
|
|
)
|
|
return self._timeoutTest(onDone, clientFactory)
|
|
|
|
def test_SMTPClientRecipientUnicode(self):
|
|
"""
|
|
Use a L{unicode} recipient.
|
|
"""
|
|
onDone = defer.Deferred()
|
|
clientFactory = smtp.SMTPSenderFactory(
|
|
"source@address",
|
|
"recipient@address",
|
|
BytesIO(b"Message body"),
|
|
onDone,
|
|
retries=0,
|
|
timeout=0.5,
|
|
)
|
|
return self._timeoutTest(onDone, clientFactory)
|
|
|
|
def test_SMTPClientRecipientList(self):
|
|
"""
|
|
Use a L{list} of recipients.
|
|
"""
|
|
onDone = defer.Deferred()
|
|
clientFactory = smtp.SMTPSenderFactory(
|
|
"source@address",
|
|
("recipient1@address", b"recipient2@address"),
|
|
BytesIO(b"Message body"),
|
|
onDone,
|
|
retries=0,
|
|
timeout=0.5,
|
|
)
|
|
return self._timeoutTest(onDone, clientFactory)
|
|
|
|
def test_ESMTPClient(self):
|
|
"""
|
|
Test timeout for L{smtp.ESMTPSenderFactory}: the response L{Deferred}
|
|
should be errback with a L{smtp.SMTPTimeoutError}.
|
|
"""
|
|
onDone = defer.Deferred()
|
|
clientFactory = smtp.ESMTPSenderFactory(
|
|
"username",
|
|
"password",
|
|
"source@address",
|
|
"recipient@address",
|
|
BytesIO(b"Message body"),
|
|
onDone,
|
|
retries=0,
|
|
timeout=0.5,
|
|
)
|
|
return self._timeoutTest(onDone, clientFactory)
|
|
|
|
def test_resetTimeoutWhileSending(self):
|
|
"""
|
|
The timeout is not allowed to expire after the server has accepted a
|
|
DATA command and the client is actively sending data to it.
|
|
"""
|
|
|
|
class SlowFile:
|
|
"""
|
|
A file-like which returns one byte from each read call until the
|
|
specified number of bytes have been returned.
|
|
"""
|
|
|
|
def __init__(self, size):
|
|
self._size = size
|
|
|
|
def read(self, max=None):
|
|
if self._size:
|
|
self._size -= 1
|
|
return b"x"
|
|
return b""
|
|
|
|
failed = []
|
|
onDone = defer.Deferred()
|
|
onDone.addErrback(failed.append)
|
|
clientFactory = smtp.SMTPSenderFactory(
|
|
"source@address",
|
|
"recipient@address",
|
|
SlowFile(1),
|
|
onDone,
|
|
retries=0,
|
|
timeout=3,
|
|
)
|
|
clientFactory.domain = b"example.org"
|
|
clock = task.Clock()
|
|
client = clientFactory.buildProtocol(
|
|
address.IPv4Address("TCP", "example.net", 25)
|
|
)
|
|
client.callLater = clock.callLater
|
|
transport = StringTransport()
|
|
client.makeConnection(transport)
|
|
|
|
client.dataReceived(
|
|
b"220 Ok\r\n" # Greet the client
|
|
b"250 Ok\r\n" # Respond to HELO
|
|
b"250 Ok\r\n" # Respond to MAIL FROM
|
|
b"250 Ok\r\n" # Respond to RCPT TO
|
|
b"354 Ok\r\n" # Respond to DATA
|
|
)
|
|
|
|
# Now the client is producing data to the server. Any time
|
|
# resumeProducing is called on the producer, the timeout should be
|
|
# extended. First, a sanity check. This test is only written to
|
|
# handle pull producers.
|
|
self.assertNotIdentical(transport.producer, None)
|
|
self.assertFalse(transport.streaming)
|
|
|
|
# Now, allow 2 seconds (1 less than the timeout of 3 seconds) to
|
|
# elapse.
|
|
clock.advance(2)
|
|
|
|
# The timeout has not expired, so the failure should not have happened.
|
|
self.assertEqual(failed, [])
|
|
|
|
# Let some bytes be produced, extending the timeout. Then advance the
|
|
# clock some more and verify that the timeout still hasn't happened.
|
|
transport.producer.resumeProducing()
|
|
clock.advance(2)
|
|
self.assertEqual(failed, [])
|
|
|
|
# The file has been completely produced - the next resume producing
|
|
# finishes the upload, successfully.
|
|
transport.producer.resumeProducing()
|
|
client.dataReceived(b"250 Ok\r\n")
|
|
self.assertEqual(failed, [])
|
|
|
|
# Verify that the client actually did send the things expected.
|
|
self.assertEqual(
|
|
transport.value(),
|
|
b"HELO example.org\r\n"
|
|
b"MAIL FROM:<source@address>\r\n"
|
|
b"RCPT TO:<recipient@address>\r\n"
|
|
b"DATA\r\n"
|
|
b"x\r\n"
|
|
b".\r\n"
|
|
# This RSET is just an implementation detail. It's nice, but this
|
|
# test doesn't really care about it.
|
|
b"RSET\r\n",
|
|
)
|
|
|
|
|
|
class MultipleDeliveryFactorySMTPServerFactory(protocol.ServerFactory):
|
|
"""
|
|
L{MultipleDeliveryFactorySMTPServerFactory} creates SMTP server protocol
|
|
instances with message delivery factory objects supplied to it. Each
|
|
factory is used for one connection and then discarded. Factories are used
|
|
in the order they are supplied.
|
|
"""
|
|
|
|
def __init__(self, messageFactories):
|
|
self._messageFactories = messageFactories
|
|
|
|
def buildProtocol(self, addr):
|
|
p = protocol.ServerFactory.buildProtocol(self, addr)
|
|
p.delivery = SimpleDelivery(self._messageFactories.pop(0))
|
|
return p
|
|
|
|
|
|
class SMTPSenderFactoryTests(TestCase):
|
|
"""
|
|
Tests for L{smtp.SMTPSenderFactory}.
|
|
"""
|
|
|
|
def test_removeCurrentProtocolWhenClientConnectionLost(self):
|
|
"""
|
|
L{smtp.SMTPSenderFactory} removes the current protocol when the client
|
|
connection is lost.
|
|
"""
|
|
reactor = MemoryReactor()
|
|
sentDeferred = defer.Deferred()
|
|
clientFactory = smtp.SMTPSenderFactory(
|
|
"source@address", "recipient@address", BytesIO(b"message"), sentDeferred
|
|
)
|
|
connector = reactor.connectTCP("localhost", 25, clientFactory)
|
|
clientFactory.buildProtocol(None)
|
|
clientFactory.clientConnectionLost(connector, error.ConnectionDone("Bye."))
|
|
self.assertEqual(clientFactory.currentProtocol, None)
|
|
|
|
def test_removeCurrentProtocolWhenClientConnectionFailed(self):
|
|
"""
|
|
L{smtp.SMTPSenderFactory} removes the current protocol when the client
|
|
connection is failed.
|
|
"""
|
|
reactor = MemoryReactor()
|
|
sentDeferred = defer.Deferred()
|
|
clientFactory = smtp.SMTPSenderFactory(
|
|
"source@address", "recipient@address", BytesIO(b"message"), sentDeferred
|
|
)
|
|
connector = reactor.connectTCP("localhost", 25, clientFactory)
|
|
clientFactory.buildProtocol(None)
|
|
clientFactory.clientConnectionFailed(connector, error.ConnectionDone("Bye."))
|
|
self.assertEqual(clientFactory.currentProtocol, None)
|
|
|
|
|
|
class SMTPSenderFactoryRetryTests(TestCase):
|
|
"""
|
|
Tests for the retry behavior of L{smtp.SMTPSenderFactory}.
|
|
"""
|
|
|
|
def test_retryAfterDisconnect(self):
|
|
"""
|
|
If the protocol created by L{SMTPSenderFactory} loses its connection
|
|
before receiving confirmation of message delivery, it reconnects and
|
|
tries to deliver the message again.
|
|
"""
|
|
recipient = b"alice"
|
|
message = b"some message text"
|
|
domain = DummyDomain([recipient])
|
|
|
|
class CleanSMTP(smtp.SMTP):
|
|
"""
|
|
An SMTP subclass which ensures that its transport will be
|
|
disconnected before the test ends.
|
|
"""
|
|
|
|
def makeConnection(innerSelf, transport):
|
|
self.addCleanup(transport.loseConnection)
|
|
smtp.SMTP.makeConnection(innerSelf, transport)
|
|
|
|
# Create a server which will fail the first message deliver attempt to
|
|
# it with a 500 and a disconnect, but which will accept a message
|
|
# delivered over the 2nd connection to it.
|
|
serverFactory = MultipleDeliveryFactorySMTPServerFactory(
|
|
[BrokenMessage, lambda user: DummyMessage(domain, user)]
|
|
)
|
|
serverFactory.protocol = CleanSMTP
|
|
serverPort = reactor.listenTCP(0, serverFactory, interface="127.0.0.1")
|
|
serverHost = serverPort.getHost()
|
|
self.addCleanup(serverPort.stopListening)
|
|
|
|
# Set up a client to try to deliver a message to the above created
|
|
# server.
|
|
sentDeferred = defer.Deferred()
|
|
clientFactory = smtp.SMTPSenderFactory(
|
|
b"bob@example.org",
|
|
recipient + b"@example.com",
|
|
BytesIO(message),
|
|
sentDeferred,
|
|
)
|
|
clientFactory.domain = b"example.org"
|
|
clientConnector = reactor.connectTCP(
|
|
serverHost.host, serverHost.port, clientFactory
|
|
)
|
|
self.addCleanup(clientConnector.disconnect)
|
|
|
|
def cbSent(ignored):
|
|
"""
|
|
Verify that the message was successfully delivered and flush the
|
|
error which caused the first attempt to fail.
|
|
"""
|
|
self.assertEqual(domain.messages, {recipient: [b"\n" + message + b"\n"]})
|
|
# Flush the RuntimeError that BrokenMessage caused to be logged.
|
|
self.assertEqual(len(self.flushLoggedErrors(RuntimeError)), 1)
|
|
|
|
sentDeferred.addCallback(cbSent)
|
|
return sentDeferred
|
|
|
|
|
|
@implementer(IRealm)
|
|
class SingletonRealm:
|
|
"""
|
|
Trivial realm implementation which is constructed with an interface and an
|
|
avatar and returns that avatar when asked for that interface.
|
|
"""
|
|
|
|
def __init__(self, interface, avatar):
|
|
self.interface = interface
|
|
self.avatar = avatar
|
|
|
|
def requestAvatar(self, avatarId, mind, *interfaces):
|
|
for iface in interfaces:
|
|
if iface is self.interface:
|
|
return iface, self.avatar, lambda: None
|
|
|
|
|
|
class NotImplementedDelivery:
|
|
"""
|
|
Non-implementation of L{smtp.IMessageDelivery} which only has methods which
|
|
raise L{NotImplementedError}. Subclassed by various tests to provide the
|
|
particular behavior being tested.
|
|
"""
|
|
|
|
def validateFrom(self, helo, origin):
|
|
raise NotImplementedError("This oughtn't be called in the course of this test.")
|
|
|
|
def validateTo(self, user):
|
|
raise NotImplementedError("This oughtn't be called in the course of this test.")
|
|
|
|
def receivedHeader(self, helo, origin, recipients):
|
|
raise NotImplementedError("This oughtn't be called in the course of this test.")
|
|
|
|
|
|
class SMTPServerTests(TestCase):
|
|
"""
|
|
Test various behaviors of L{twisted.mail.smtp.SMTP} and
|
|
L{twisted.mail.smtp.ESMTP}.
|
|
"""
|
|
|
|
def testSMTPGreetingHost(self, serverClass=smtp.SMTP):
|
|
"""
|
|
Test that the specified hostname shows up in the SMTP server's
|
|
greeting.
|
|
"""
|
|
s = serverClass()
|
|
s.host = b"example.com"
|
|
t = StringTransport()
|
|
s.makeConnection(t)
|
|
s.connectionLost(error.ConnectionDone())
|
|
self.assertIn(b"example.com", t.value())
|
|
|
|
def testSMTPGreetingNotExtended(self):
|
|
"""
|
|
Test that the string "ESMTP" does not appear in the SMTP server's
|
|
greeting since that string strongly suggests the presence of support
|
|
for various SMTP extensions which are not supported by L{smtp.SMTP}.
|
|
"""
|
|
s = smtp.SMTP()
|
|
t = StringTransport()
|
|
s.makeConnection(t)
|
|
s.connectionLost(error.ConnectionDone())
|
|
self.assertNotIn(b"ESMTP", t.value())
|
|
|
|
def testESMTPGreetingHost(self):
|
|
"""
|
|
Similar to testSMTPGreetingHost, but for the L{smtp.ESMTP} class.
|
|
"""
|
|
self.testSMTPGreetingHost(smtp.ESMTP)
|
|
|
|
def testESMTPGreetingExtended(self):
|
|
"""
|
|
Test that the string "ESMTP" does appear in the ESMTP server's
|
|
greeting since L{smtp.ESMTP} does support the SMTP extensions which
|
|
that advertises to the client.
|
|
"""
|
|
s = smtp.ESMTP()
|
|
t = StringTransport()
|
|
s.makeConnection(t)
|
|
s.connectionLost(error.ConnectionDone())
|
|
self.assertIn(b"ESMTP", t.value())
|
|
|
|
def test_SMTPUnknownCommand(self):
|
|
"""
|
|
Sending an unimplemented command is responded to with a 500.
|
|
"""
|
|
s = smtp.SMTP()
|
|
t = StringTransport()
|
|
s.makeConnection(t)
|
|
s.lineReceived(b"DOAGOODTHING")
|
|
s.connectionLost(error.ConnectionDone())
|
|
self.assertIn(b"500 Command not implemented", t.value())
|
|
|
|
def test_acceptSenderAddress(self):
|
|
"""
|
|
Test that a C{MAIL FROM} command with an acceptable address is
|
|
responded to with the correct success code.
|
|
"""
|
|
|
|
class AcceptanceDelivery(NotImplementedDelivery):
|
|
"""
|
|
Delivery object which accepts all senders as valid.
|
|
"""
|
|
|
|
def validateFrom(self, helo, origin):
|
|
return origin
|
|
|
|
realm = SingletonRealm(smtp.IMessageDelivery, AcceptanceDelivery())
|
|
portal = Portal(realm, [AllowAnonymousAccess()])
|
|
proto = smtp.SMTP()
|
|
proto.portal = portal
|
|
trans = StringTransport()
|
|
proto.makeConnection(trans)
|
|
|
|
# Deal with the necessary preliminaries
|
|
proto.dataReceived(b"HELO example.com\r\n")
|
|
trans.clear()
|
|
|
|
# Try to specify our sender address
|
|
proto.dataReceived(b"MAIL FROM:<alice@example.com>\r\n")
|
|
|
|
# Clean up the protocol before doing anything that might raise an
|
|
# exception.
|
|
proto.connectionLost(error.ConnectionLost())
|
|
|
|
# Make sure that we received exactly the correct response
|
|
self.assertEqual(trans.value(), b"250 Sender address accepted\r\n")
|
|
|
|
def test_deliveryRejectedSenderAddress(self):
|
|
"""
|
|
Test that a C{MAIL FROM} command with an address rejected by a
|
|
L{smtp.IMessageDelivery} instance is responded to with the correct
|
|
error code.
|
|
"""
|
|
|
|
class RejectionDelivery(NotImplementedDelivery):
|
|
"""
|
|
Delivery object which rejects all senders as invalid.
|
|
"""
|
|
|
|
def validateFrom(self, helo, origin):
|
|
raise smtp.SMTPBadSender(origin)
|
|
|
|
realm = SingletonRealm(smtp.IMessageDelivery, RejectionDelivery())
|
|
portal = Portal(realm, [AllowAnonymousAccess()])
|
|
proto = smtp.SMTP()
|
|
proto.portal = portal
|
|
trans = StringTransport()
|
|
proto.makeConnection(trans)
|
|
|
|
# Deal with the necessary preliminaries
|
|
proto.dataReceived(b"HELO example.com\r\n")
|
|
trans.clear()
|
|
|
|
# Try to specify our sender address
|
|
proto.dataReceived(b"MAIL FROM:<alice@example.com>\r\n")
|
|
|
|
# Clean up the protocol before doing anything that might raise an
|
|
# exception.
|
|
proto.connectionLost(error.ConnectionLost())
|
|
|
|
# Make sure that we received exactly the correct response
|
|
self.assertEqual(
|
|
trans.value(),
|
|
b"550 Cannot receive from specified address "
|
|
b"<alice@example.com>: Sender not acceptable\r\n",
|
|
)
|
|
|
|
@implementer(ICredentialsChecker)
|
|
def test_portalRejectedSenderAddress(self):
|
|
"""
|
|
Test that a C{MAIL FROM} command with an address rejected by an
|
|
L{smtp.SMTP} instance's portal is responded to with the correct error
|
|
code.
|
|
"""
|
|
|
|
class DisallowAnonymousAccess:
|
|
"""
|
|
Checker for L{IAnonymous} which rejects authentication attempts.
|
|
"""
|
|
|
|
credentialInterfaces = (IAnonymous,)
|
|
|
|
def requestAvatarId(self, credentials):
|
|
return defer.fail(UnauthorizedLogin())
|
|
|
|
realm = SingletonRealm(smtp.IMessageDelivery, NotImplementedDelivery())
|
|
portal = Portal(realm, [DisallowAnonymousAccess()])
|
|
proto = smtp.SMTP()
|
|
proto.portal = portal
|
|
trans = StringTransport()
|
|
proto.makeConnection(trans)
|
|
|
|
# Deal with the necessary preliminaries
|
|
proto.dataReceived(b"HELO example.com\r\n")
|
|
trans.clear()
|
|
|
|
# Try to specify our sender address
|
|
proto.dataReceived(b"MAIL FROM:<alice@example.com>\r\n")
|
|
|
|
# Clean up the protocol before doing anything that might raise an
|
|
# exception.
|
|
proto.connectionLost(error.ConnectionLost())
|
|
|
|
# Make sure that we received exactly the correct response
|
|
self.assertEqual(
|
|
trans.value(),
|
|
b"550 Cannot receive from specified address "
|
|
b"<alice@example.com>: Sender not acceptable\r\n",
|
|
)
|
|
|
|
def test_portalRejectedAnonymousSender(self):
|
|
"""
|
|
Test that a C{MAIL FROM} command issued without first authenticating
|
|
when a portal has been configured to disallow anonymous logins is
|
|
responded to with the correct error code.
|
|
"""
|
|
realm = SingletonRealm(smtp.IMessageDelivery, NotImplementedDelivery())
|
|
portal = Portal(realm, [])
|
|
proto = smtp.SMTP()
|
|
proto.portal = portal
|
|
trans = StringTransport()
|
|
proto.makeConnection(trans)
|
|
|
|
# Deal with the necessary preliminaries
|
|
proto.dataReceived(b"HELO example.com\r\n")
|
|
trans.clear()
|
|
|
|
# Try to specify our sender address
|
|
proto.dataReceived(b"MAIL FROM:<alice@example.com>\r\n")
|
|
|
|
# Clean up the protocol before doing anything that might raise an
|
|
# exception.
|
|
proto.connectionLost(error.ConnectionLost())
|
|
|
|
# Make sure that we received exactly the correct response
|
|
self.assertEqual(
|
|
trans.value(),
|
|
b"550 Cannot receive from specified address "
|
|
b"<alice@example.com>: Unauthenticated senders not allowed\r\n",
|
|
)
|
|
|
|
|
|
class ESMTPAuthenticationTests(TestCase):
|
|
def assertServerResponse(self, bytes, response):
|
|
"""
|
|
Assert that when the given bytes are delivered to the ESMTP server
|
|
instance, it responds with the indicated lines.
|
|
|
|
@type bytes: str
|
|
@type response: list of str
|
|
"""
|
|
self.transport.clear()
|
|
self.server.dataReceived(bytes)
|
|
self.assertEqual(response, self.transport.value().splitlines())
|
|
|
|
def assertServerAuthenticated(
|
|
self, loginArgs, username=b"username", password=b"password"
|
|
):
|
|
"""
|
|
Assert that a login attempt has been made, that the credentials and
|
|
interfaces passed to it are correct, and that when the login request
|
|
is satisfied, a successful response is sent by the ESMTP server
|
|
instance.
|
|
|
|
@param loginArgs: A C{list} previously passed to L{portalFactory}.
|
|
@param username: The login user.
|
|
@param password: The login password.
|
|
"""
|
|
d, credentials, mind, interfaces = loginArgs.pop()
|
|
self.assertEqual(loginArgs, [])
|
|
self.assertTrue(
|
|
twisted.cred.credentials.IUsernamePassword.providedBy(credentials)
|
|
)
|
|
self.assertEqual(credentials.username, username)
|
|
self.assertTrue(credentials.checkPassword(password))
|
|
self.assertIn(smtp.IMessageDeliveryFactory, interfaces)
|
|
self.assertIn(smtp.IMessageDelivery, interfaces)
|
|
d.callback((smtp.IMessageDeliveryFactory, None, lambda: None))
|
|
|
|
self.assertEqual(
|
|
[b"235 Authentication successful."], self.transport.value().splitlines()
|
|
)
|
|
|
|
def setUp(self):
|
|
"""
|
|
Create an ESMTP instance attached to a StringTransport.
|
|
"""
|
|
self.server = smtp.ESMTP({b"LOGIN": LOGINCredentials})
|
|
self.server.host = b"localhost"
|
|
self.transport = StringTransport(
|
|
peerAddress=address.IPv4Address("TCP", "127.0.0.1", 12345)
|
|
)
|
|
self.server.makeConnection(self.transport)
|
|
|
|
def tearDown(self):
|
|
"""
|
|
Disconnect the ESMTP instance to clean up its timeout DelayedCall.
|
|
"""
|
|
self.server.connectionLost(error.ConnectionDone())
|
|
|
|
def portalFactory(self, loginList):
|
|
class DummyPortal:
|
|
def login(self, credentials, mind, *interfaces):
|
|
d = defer.Deferred()
|
|
loginList.append((d, credentials, mind, interfaces))
|
|
return d
|
|
|
|
return DummyPortal()
|
|
|
|
def test_authenticationCapabilityAdvertised(self):
|
|
"""
|
|
Test that AUTH is advertised to clients which issue an EHLO command.
|
|
"""
|
|
self.transport.clear()
|
|
self.server.dataReceived(b"EHLO\r\n")
|
|
responseLines = self.transport.value().splitlines()
|
|
self.assertEqual(
|
|
responseLines[0], b"250-localhost Hello 127.0.0.1, nice to meet you"
|
|
)
|
|
self.assertEqual(responseLines[1], b"250 AUTH LOGIN")
|
|
self.assertEqual(len(responseLines), 2)
|
|
|
|
def test_plainAuthentication(self):
|
|
"""
|
|
Test that the LOGIN authentication mechanism can be used
|
|
"""
|
|
loginArgs = []
|
|
self.server.portal = self.portalFactory(loginArgs)
|
|
|
|
self.server.dataReceived(b"EHLO\r\n")
|
|
self.transport.clear()
|
|
|
|
self.assertServerResponse(
|
|
b"AUTH LOGIN\r\n", [b"334 " + base64.b64encode(b"User Name\0").strip()]
|
|
)
|
|
|
|
self.assertServerResponse(
|
|
base64.b64encode(b"username") + b"\r\n",
|
|
[b"334 " + base64.b64encode(b"Password\0").strip()],
|
|
)
|
|
|
|
self.assertServerResponse(base64.b64encode(b"password").strip() + b"\r\n", [])
|
|
|
|
self.assertServerAuthenticated(loginArgs)
|
|
|
|
def test_plainAuthenticationEmptyPassword(self):
|
|
"""
|
|
Test that giving an empty password for plain auth succeeds.
|
|
"""
|
|
loginArgs = []
|
|
self.server.portal = self.portalFactory(loginArgs)
|
|
|
|
self.server.dataReceived(b"EHLO\r\n")
|
|
self.transport.clear()
|
|
|
|
self.assertServerResponse(
|
|
b"AUTH LOGIN\r\n", [b"334 " + base64.b64encode(b"User Name\0").strip()]
|
|
)
|
|
|
|
self.assertServerResponse(
|
|
base64.b64encode(b"username") + b"\r\n",
|
|
[b"334 " + base64.b64encode(b"Password\0").strip()],
|
|
)
|
|
|
|
self.assertServerResponse(b"\r\n", [])
|
|
self.assertServerAuthenticated(loginArgs, password=b"")
|
|
|
|
def test_plainAuthenticationInitialResponse(self):
|
|
"""
|
|
The response to the first challenge may be included on the AUTH command
|
|
line. Test that this is also supported.
|
|
"""
|
|
loginArgs = []
|
|
self.server.portal = self.portalFactory(loginArgs)
|
|
|
|
self.server.dataReceived(b"EHLO\r\n")
|
|
self.transport.clear()
|
|
|
|
self.assertServerResponse(
|
|
b"AUTH LOGIN " + base64.b64encode(b"username").strip() + b"\r\n",
|
|
[b"334 " + base64.b64encode(b"Password\0").strip()],
|
|
)
|
|
|
|
self.assertServerResponse(base64.b64encode(b"password").strip() + b"\r\n", [])
|
|
|
|
self.assertServerAuthenticated(loginArgs)
|
|
|
|
def test_abortAuthentication(self):
|
|
"""
|
|
Test that a challenge/response sequence can be aborted by the client.
|
|
"""
|
|
loginArgs = []
|
|
self.server.portal = self.portalFactory(loginArgs)
|
|
|
|
self.server.dataReceived(b"EHLO\r\n")
|
|
self.server.dataReceived(b"AUTH LOGIN\r\n")
|
|
|
|
self.assertServerResponse(b"*\r\n", [b"501 Authentication aborted"])
|
|
|
|
def test_invalidBase64EncodedResponse(self):
|
|
"""
|
|
Test that a response which is not properly Base64 encoded results in
|
|
the appropriate error code.
|
|
"""
|
|
loginArgs = []
|
|
self.server.portal = self.portalFactory(loginArgs)
|
|
|
|
self.server.dataReceived(b"EHLO\r\n")
|
|
self.server.dataReceived(b"AUTH LOGIN\r\n")
|
|
|
|
self.assertServerResponse(
|
|
b"x\r\n", [b"501 Syntax error in parameters or arguments"]
|
|
)
|
|
|
|
self.assertEqual(loginArgs, [])
|
|
|
|
def test_invalidBase64EncodedInitialResponse(self):
|
|
"""
|
|
Like L{test_invalidBase64EncodedResponse} but for the case of an
|
|
initial response included with the C{AUTH} command.
|
|
"""
|
|
loginArgs = []
|
|
self.server.portal = self.portalFactory(loginArgs)
|
|
|
|
self.server.dataReceived(b"EHLO\r\n")
|
|
self.assertServerResponse(
|
|
b"AUTH LOGIN x\r\n", [b"501 Syntax error in parameters or arguments"]
|
|
)
|
|
|
|
self.assertEqual(loginArgs, [])
|
|
|
|
def test_unexpectedLoginFailure(self):
|
|
"""
|
|
If the L{Deferred} returned by L{Portal.login} fires with an
|
|
exception of any type other than L{UnauthorizedLogin}, the exception
|
|
is logged and the client is informed that the authentication attempt
|
|
has failed.
|
|
"""
|
|
loginArgs = []
|
|
self.server.portal = self.portalFactory(loginArgs)
|
|
|
|
self.server.dataReceived(b"EHLO\r\n")
|
|
self.transport.clear()
|
|
|
|
self.assertServerResponse(
|
|
b"AUTH LOGIN " + base64.b64encode(b"username").strip() + b"\r\n",
|
|
[b"334 " + base64.b64encode(b"Password\0").strip()],
|
|
)
|
|
self.assertServerResponse(base64.b64encode(b"password").strip() + b"\r\n", [])
|
|
|
|
d, credentials, mind, interfaces = loginArgs.pop()
|
|
d.errback(RuntimeError("Something wrong with the server"))
|
|
|
|
self.assertEqual(
|
|
b"451 Requested action aborted: local error in processing\r\n",
|
|
self.transport.value(),
|
|
)
|
|
|
|
self.assertEqual(len(self.flushLoggedErrors(RuntimeError)), 1)
|
|
|
|
|
|
class SMTPClientErrorTests(TestCase):
|
|
"""
|
|
Tests for L{smtp.SMTPClientError}.
|
|
"""
|
|
|
|
def test_str(self):
|
|
"""
|
|
The string representation of a L{SMTPClientError} instance includes
|
|
the response code and response string.
|
|
"""
|
|
err = smtp.SMTPClientError(123, "some text")
|
|
self.assertEqual(str(err), "123 some text")
|
|
|
|
def test_strWithNegativeCode(self):
|
|
"""
|
|
If the response code supplied to L{SMTPClientError} is negative, it
|
|
is excluded from the string representation.
|
|
"""
|
|
err = smtp.SMTPClientError(-1, b"foo bar")
|
|
self.assertEqual(str(err), "foo bar")
|
|
|
|
def test_strWithLog(self):
|
|
"""
|
|
If a line log is supplied to L{SMTPClientError}, its contents are
|
|
included in the string representation of the exception instance.
|
|
"""
|
|
log = LineLog(10)
|
|
log.append(b"testlog")
|
|
log.append(b"secondline")
|
|
err = smtp.SMTPClientError(100, "test error", log=log.str())
|
|
self.assertEqual(str(err), "100 test error\n" "testlog\n" "secondline\n")
|
|
|
|
|
|
class SenderMixinSentMailTests(TestCase):
|
|
"""
|
|
Tests for L{smtp.SenderMixin.sentMail}, used in particular by
|
|
L{smtp.SMTPSenderFactory} and L{smtp.ESMTPSenderFactory}.
|
|
"""
|
|
|
|
def test_onlyLogFailedAddresses(self):
|
|
"""
|
|
L{smtp.SenderMixin.sentMail} adds only the addresses with failing
|
|
SMTP response codes to the log passed to the factory's errback.
|
|
"""
|
|
onDone = self.assertFailure(defer.Deferred(), smtp.SMTPDeliveryError)
|
|
onDone.addCallback(
|
|
lambda e: self.assertEqual(
|
|
e.log, b"bob@example.com: 199 Error in sending.\n"
|
|
)
|
|
)
|
|
|
|
clientFactory = smtp.SMTPSenderFactory(
|
|
"source@address",
|
|
"recipient@address",
|
|
BytesIO(b"Message body"),
|
|
onDone,
|
|
retries=0,
|
|
timeout=0.5,
|
|
)
|
|
|
|
client = clientFactory.buildProtocol(
|
|
address.IPv4Address("TCP", "example.net", 25)
|
|
)
|
|
|
|
addresses = [
|
|
(b"alice@example.com", 200, b"No errors here!"),
|
|
(b"bob@example.com", 199, b"Error in sending."),
|
|
]
|
|
client.sentMail(199, b"Test response", 1, addresses, client.log)
|
|
|
|
return onDone
|
|
|
|
|
|
class ESMTPDowngradeTestCase(TestCase):
|
|
"""
|
|
Tests for the ESMTP -> SMTP downgrade functionality in L{smtp.ESMTPClient}.
|
|
"""
|
|
|
|
def setUp(self):
|
|
self.clientProtocol = smtp.ESMTPClient(b"testpassword", None, b"testuser")
|
|
|
|
def test_requireHELOFallbackOperates(self):
|
|
"""
|
|
If both authentication and transport security are not required, and it
|
|
is asked for, it will fall back to allowing HELO.
|
|
"""
|
|
transport = StringTransport()
|
|
self.clientProtocol.requireAuthentication = False
|
|
self.clientProtocol.requireTransportSecurity = False
|
|
self.clientProtocol.heloFallback = True
|
|
self.clientProtocol.makeConnection(transport)
|
|
|
|
self.clientProtocol.dataReceived(b"220 localhost\r\n")
|
|
transport.clear()
|
|
self.clientProtocol.dataReceived(b"500 not an esmtp server\r\n")
|
|
self.assertEqual(b"HELO testuser\r\n", transport.value())
|
|
|
|
def test_requireAuthFailsHELOFallback(self):
|
|
"""
|
|
If authentication is required, and HELO fallback is on, HELO fallback
|
|
must not be honoured, as authentication requires EHLO to succeed.
|
|
"""
|
|
transport = StringTransport()
|
|
self.clientProtocol.requireAuthentication = True
|
|
self.clientProtocol.requireTransportSecurity = False
|
|
self.clientProtocol.heloFallback = True
|
|
self.clientProtocol.makeConnection(transport)
|
|
|
|
self.clientProtocol.dataReceived(b"220 localhost\r\n")
|
|
transport.clear()
|
|
self.clientProtocol.dataReceived(b"500 not an esmtp server\r\n")
|
|
self.assertEqual(b"QUIT\r\n", transport.value())
|
|
|
|
def test_requireTLSFailsHELOFallback(self):
|
|
"""
|
|
If TLS is required and the connection is insecure, HELO fallback must
|
|
not be honoured, as STARTTLS requires EHLO to succeed.
|
|
"""
|
|
transport = StringTransport()
|
|
self.clientProtocol.requireAuthentication = False
|
|
self.clientProtocol.requireTransportSecurity = True
|
|
self.clientProtocol.heloFallback = True
|
|
self.clientProtocol.makeConnection(transport)
|
|
|
|
self.clientProtocol.dataReceived(b"220 localhost\r\n")
|
|
transport.clear()
|
|
self.clientProtocol.dataReceived(b"500 not an esmtp server\r\n")
|
|
self.assertEqual(b"QUIT\r\n", transport.value())
|
|
|
|
def test_requireTLSAndHELOFallbackSucceedsIfOverTLS(self):
|
|
"""
|
|
If TLS is provided at the transport level, we can honour the HELO
|
|
fallback if we're set to require TLS.
|
|
"""
|
|
transport = StringTransport()
|
|
directlyProvides(transport, interfaces.ISSLTransport)
|
|
self.clientProtocol.requireAuthentication = False
|
|
self.clientProtocol.requireTransportSecurity = True
|
|
self.clientProtocol.heloFallback = True
|
|
self.clientProtocol.makeConnection(transport)
|
|
|
|
self.clientProtocol.dataReceived(b"220 localhost\r\n")
|
|
transport.clear()
|
|
self.clientProtocol.dataReceived(b"500 not an esmtp server\r\n")
|
|
self.assertEqual(b"HELO testuser\r\n", transport.value())
|
|
|
|
|
|
class SSLTestCase(TestCase):
|
|
"""
|
|
Tests for the TLS negotiation done by L{smtp.ESMTPClient}.
|
|
"""
|
|
|
|
skip = sslSkip
|
|
|
|
SERVER_GREETING = b"220 localhost NO UCE NO UBE NO RELAY PROBES ESMTP\r\n"
|
|
EHLO_RESPONSE = b"250-localhost Hello 127.0.0.1, nice to meet you\r\n"
|
|
|
|
def setUp(self):
|
|
self.clientProtocol = smtp.ESMTPClient(
|
|
b"testpassword", ClientTLSContext(), b"testuser"
|
|
)
|
|
self.clientProtocol.requireTransportSecurity = True
|
|
self.clientProtocol.getMailFrom = lambda: "test@example.org"
|
|
|
|
def _requireTransportSecurityOverSSLTest(self, capabilities):
|
|
"""
|
|
Verify that when L{smtp.ESMTPClient} connects to a server over a
|
|
transport providing L{ISSLTransport}, C{requireTransportSecurity} is
|
|
C{True}, and it is presented with the given capabilities, it will try
|
|
to send its mail and not first attempt to negotiate TLS using the
|
|
I{STARTTLS} protocol action.
|
|
|
|
@param capabilities: Bytes to include in the test server's capability
|
|
response. These must be formatted exactly as required by the
|
|
protocol, including a line which ends the capability response.
|
|
@type param: L{bytes}
|
|
|
|
@raise: C{self.failureException} if the behavior of
|
|
C{self.clientProtocol} is not as described.
|
|
"""
|
|
transport = StringTransport()
|
|
directlyProvides(transport, interfaces.ISSLTransport)
|
|
self.clientProtocol.makeConnection(transport)
|
|
|
|
# Get the handshake out of the way
|
|
self.clientProtocol.dataReceived(self.SERVER_GREETING)
|
|
transport.clear()
|
|
|
|
# Tell the client about the server's capabilities
|
|
self.clientProtocol.dataReceived(self.EHLO_RESPONSE + capabilities)
|
|
|
|
# The client should now try to send a message - without first trying to
|
|
# negotiate TLS, since the transport is already secure.
|
|
self.assertEqual(b"MAIL FROM:<test@example.org>\r\n", transport.value())
|
|
|
|
def test_requireTransportSecurityOverSSL(self):
|
|
"""
|
|
When C{requireTransportSecurity} is C{True} and the client is connected
|
|
over an SSL transport, mail may be delivered.
|
|
"""
|
|
self._requireTransportSecurityOverSSLTest(b"250 AUTH LOGIN\r\n")
|
|
|
|
def test_requireTransportSecurityTLSOffered(self):
|
|
"""
|
|
When C{requireTransportSecurity} is C{True} and the client is connected
|
|
over a non-SSL transport, if the server offers the I{STARTTLS}
|
|
extension, it is used before mail is delivered.
|
|
"""
|
|
transport = StringTransport()
|
|
self.clientProtocol.makeConnection(transport)
|
|
|
|
# Get the handshake out of the way
|
|
self.clientProtocol.dataReceived(self.SERVER_GREETING)
|
|
transport.clear()
|
|
|
|
# Tell the client about the server's capabilities - including STARTTLS
|
|
self.clientProtocol.dataReceived(
|
|
self.EHLO_RESPONSE + b"250-AUTH LOGIN\r\n" b"250 STARTTLS\r\n"
|
|
)
|
|
|
|
# The client should try to start TLS before sending the message.
|
|
self.assertEqual(b"STARTTLS\r\n", transport.value())
|
|
|
|
def test_requireTransportSecurityTLSOfferedOverSSL(self):
|
|
"""
|
|
When C{requireTransportSecurity} is C{True} and the client is connected
|
|
over an SSL transport, if the server offers the I{STARTTLS}
|
|
extension, it is not used before mail is delivered.
|
|
"""
|
|
self._requireTransportSecurityOverSSLTest(
|
|
b"250-AUTH LOGIN\r\n" b"250 STARTTLS\r\n"
|
|
)
|
|
|
|
def test_requireTransportSecurityTLSNotOffered(self):
|
|
"""
|
|
When C{requireTransportSecurity} is C{True} and the client is connected
|
|
over a non-SSL transport, if the server does not offer the I{STARTTLS}
|
|
extension, mail is not delivered.
|
|
"""
|
|
transport = StringTransport()
|
|
self.clientProtocol.makeConnection(transport)
|
|
|
|
# Get the handshake out of the way
|
|
self.clientProtocol.dataReceived(self.SERVER_GREETING)
|
|
transport.clear()
|
|
|
|
# Tell the client about the server's capabilities - excluding STARTTLS
|
|
self.clientProtocol.dataReceived(self.EHLO_RESPONSE + b"250 AUTH LOGIN\r\n")
|
|
|
|
# The client give up
|
|
self.assertEqual(b"QUIT\r\n", transport.value())
|
|
|
|
def test_esmtpClientTlsModeDeprecationGet(self):
|
|
"""
|
|
L{smtp.ESMTPClient.tlsMode} is deprecated.
|
|
"""
|
|
val = self.clientProtocol.tlsMode
|
|
del val
|
|
warningsShown = self.flushWarnings(
|
|
offendingFunctions=[self.test_esmtpClientTlsModeDeprecationGet]
|
|
)
|
|
self.assertEqual(len(warningsShown), 1)
|
|
self.assertIdentical(warningsShown[0]["category"], DeprecationWarning)
|
|
self.assertEqual(
|
|
warningsShown[0]["message"],
|
|
"tlsMode attribute of twisted.mail.smtp.ESMTPClient "
|
|
"is deprecated since Twisted 13.0",
|
|
)
|
|
|
|
def test_esmtpClientTlsModeDeprecationGetAttributeError(self):
|
|
"""
|
|
L{smtp.ESMTPClient.__getattr__} raises an attribute error for other
|
|
attribute names which do not exist.
|
|
"""
|
|
self.assertRaises(AttributeError, lambda: self.clientProtocol.doesNotExist)
|
|
|
|
def test_esmtpClientTlsModeDeprecationSet(self):
|
|
"""
|
|
L{smtp.ESMTPClient.tlsMode} is deprecated.
|
|
"""
|
|
self.clientProtocol.tlsMode = False
|
|
warningsShown = self.flushWarnings(
|
|
offendingFunctions=[self.test_esmtpClientTlsModeDeprecationSet]
|
|
)
|
|
self.assertEqual(len(warningsShown), 1)
|
|
self.assertIdentical(warningsShown[0]["category"], DeprecationWarning)
|
|
self.assertEqual(
|
|
warningsShown[0]["message"],
|
|
"tlsMode attribute of twisted.mail.smtp.ESMTPClient "
|
|
"is deprecated since Twisted 13.0",
|
|
)
|
|
|
|
|
|
class AbortableStringTransport(StringTransport):
|
|
"""
|
|
A version of L{StringTransport} that supports C{abortConnection}.
|
|
"""
|
|
|
|
# This should be replaced by a common version in #6530.
|
|
aborting = False
|
|
|
|
def abortConnection(self):
|
|
"""
|
|
A testable version of the C{ITCPTransport.abortConnection} method.
|
|
|
|
Since this is a special case of closing the connection,
|
|
C{loseConnection} is also called.
|
|
"""
|
|
self.aborting = True
|
|
self.loseConnection()
|
|
|
|
|
|
class SendmailTests(TestCase):
|
|
"""
|
|
Tests for L{twisted.mail.smtp.sendmail}.
|
|
"""
|
|
|
|
def test_defaultReactorIsGlobalReactor(self):
|
|
"""
|
|
The default C{reactor} parameter of L{twisted.mail.smtp.sendmail} is
|
|
L{twisted.internet.reactor}.
|
|
"""
|
|
fullSpec = inspect.getfullargspec(smtp.sendmail)
|
|
defaults = fullSpec[3]
|
|
self.assertEqual(reactor, defaults[2])
|
|
|
|
def _honorsESMTPArguments(self, username, password):
|
|
"""
|
|
L{twisted.mail.smtp.sendmail} creates the ESMTP factory with the ESMTP
|
|
arguments.
|
|
"""
|
|
reactor = MemoryReactor()
|
|
smtp.sendmail(
|
|
"localhost",
|
|
"source@address",
|
|
"recipient@address",
|
|
b"message",
|
|
reactor=reactor,
|
|
username=username,
|
|
password=password,
|
|
requireTransportSecurity=True,
|
|
requireAuthentication=True,
|
|
)
|
|
factory = reactor.tcpClients[0][2]
|
|
self.assertEqual(factory._requireTransportSecurity, True)
|
|
self.assertEqual(factory._requireAuthentication, True)
|
|
self.assertEqual(factory.username, b"foo")
|
|
self.assertEqual(factory.password, b"bar")
|
|
|
|
def test_honorsESMTPArgumentsUnicodeUserPW(self):
|
|
"""
|
|
L{twisted.mail.smtp.sendmail} should accept C{username} and C{password}
|
|
which are L{unicode}.
|
|
"""
|
|
return self._honorsESMTPArguments(username="foo", password="bar")
|
|
|
|
def test_honorsESMTPArgumentsBytesUserPW(self):
|
|
"""
|
|
L{twisted.mail.smtp.sendmail} should accept C{username} and C{password}
|
|
which are L{bytes}.
|
|
"""
|
|
return self._honorsESMTPArguments(username=b"foo", password=b"bar")
|
|
|
|
def test_messageFilePassthrough(self):
|
|
"""
|
|
L{twisted.mail.smtp.sendmail} will pass through the message untouched
|
|
if it is a file-like object.
|
|
"""
|
|
reactor = MemoryReactor()
|
|
messageFile = BytesIO(b"File!")
|
|
|
|
smtp.sendmail(
|
|
"localhost",
|
|
"source@address",
|
|
"recipient@address",
|
|
messageFile,
|
|
reactor=reactor,
|
|
)
|
|
factory = reactor.tcpClients[0][2]
|
|
self.assertIs(factory.file, messageFile)
|
|
|
|
def test_messageStringMadeFile(self):
|
|
"""
|
|
L{twisted.mail.smtp.sendmail} will turn non-file-like objects
|
|
(eg. strings) into file-like objects before sending.
|
|
"""
|
|
reactor = MemoryReactor()
|
|
smtp.sendmail(
|
|
"localhost",
|
|
"source@address",
|
|
"recipient@address",
|
|
b"message",
|
|
reactor=reactor,
|
|
)
|
|
factory = reactor.tcpClients[0][2]
|
|
messageFile = factory.file
|
|
messageFile.seek(0)
|
|
self.assertEqual(messageFile.read(), b"message")
|
|
|
|
def test_senderDomainName(self):
|
|
"""
|
|
L{twisted.mail.smtp.sendmail} passes through the sender domain name, if
|
|
provided.
|
|
"""
|
|
reactor = MemoryReactor()
|
|
smtp.sendmail(
|
|
"localhost",
|
|
"source@address",
|
|
"recipient@address",
|
|
b"message",
|
|
reactor=reactor,
|
|
senderDomainName="foo",
|
|
)
|
|
factory = reactor.tcpClients[0][2]
|
|
self.assertEqual(factory.domain, b"foo")
|
|
|
|
def test_cancelBeforeConnectionMade(self):
|
|
"""
|
|
When a user cancels L{twisted.mail.smtp.sendmail} before the connection
|
|
is made, the connection is closed by
|
|
L{twisted.internet.interfaces.IConnector.disconnect}.
|
|
"""
|
|
reactor = MemoryReactor()
|
|
d = smtp.sendmail(
|
|
"localhost",
|
|
"source@address",
|
|
"recipient@address",
|
|
b"message",
|
|
reactor=reactor,
|
|
)
|
|
d.cancel()
|
|
self.assertEqual(reactor.connectors[0]._disconnected, True)
|
|
failure = self.failureResultOf(d)
|
|
failure.trap(defer.CancelledError)
|
|
|
|
def test_cancelAfterConnectionMade(self):
|
|
"""
|
|
When a user cancels L{twisted.mail.smtp.sendmail} after the connection
|
|
is made, the connection is closed by
|
|
L{twisted.internet.interfaces.ITransport.abortConnection}.
|
|
"""
|
|
reactor = MemoryReactor()
|
|
transport = AbortableStringTransport()
|
|
d = smtp.sendmail(
|
|
"localhost",
|
|
"source@address",
|
|
"recipient@address",
|
|
b"message",
|
|
reactor=reactor,
|
|
)
|
|
factory = reactor.tcpClients[0][2]
|
|
p = factory.buildProtocol(None)
|
|
p.makeConnection(transport)
|
|
d.cancel()
|
|
self.assertEqual(transport.aborting, True)
|
|
self.assertEqual(transport.disconnecting, True)
|
|
failure = self.failureResultOf(d)
|
|
failure.trap(defer.CancelledError)
|