diff options
Diffstat (limited to 'src/leap/bitmask/mail')
| -rw-r--r-- | src/leap/bitmask/mail/outgoing/sender.py | 130 | ||||
| -rw-r--r-- | src/leap/bitmask/mail/outgoing/service.py | 135 | ||||
| -rw-r--r-- | src/leap/bitmask/mail/smtp/gateway.py | 155 | ||||
| -rw-r--r-- | src/leap/bitmask/mail/smtp/service.py | 12 | ||||
| -rw-r--r-- | src/leap/bitmask/mail/testing/smtp.py | 22 |
5 files changed, 223 insertions, 231 deletions
diff --git a/src/leap/bitmask/mail/outgoing/sender.py b/src/leap/bitmask/mail/outgoing/sender.py new file mode 100644 index 00000000..d8c049c8 --- /dev/null +++ b/src/leap/bitmask/mail/outgoing/sender.py @@ -0,0 +1,130 @@ +# -*- coding: utf-8 -*- +# outgoing/sender.py +# Copyright (C) 2017 LEAP +# +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see <http://www.gnu.org/licenses/>. + +from OpenSSL import SSL +from StringIO import StringIO +from twisted.internet import reactor +from twisted.internet import defer +from twisted.logger import Logger +from twisted.mail import smtp +from twisted.protocols.amp import ssl +from zope.interface import Interface, implements + +from leap.common.check import leap_assert_type, leap_assert +from leap.bitmask import __version__ + + +class ISender(Interface): + def can_send(self, recipient): + """ + Checks if ISender implementor can send messages to recipient + + :type recipient: string + :rtype: bool + """ + + def send(self, recipient, message): + """ + Send a messages to recipient + + :type recipient: string + :type message: string + + :return: A Deferred that will be called with the recipient address + :raises SendError: in case of failure in send + """ + + +class SendError(Exception): + pass + + +class SMTPSender(object): + implements(ISender) + + log = Logger() + + def __init__(self, from_address, key, host, port): + """ + :param from_address: The sender address. + :type from_address: str + :param key: The client private key for SSL authentication. + :type key: str + :param host: The hostname of the remote SMTP server. + :type host: str + :param port: The port of the remote SMTP server. + :type port: int + """ + leap_assert_type(host, (str, unicode)) + leap_assert(host != '') + leap_assert_type(port, int) + leap_assert(port is not 0) + leap_assert_type(key, basestring) + leap_assert(key != '') + + self._port = port + self._host = host + self._key = key + self._from_address = from_address + + def can_send(self, recipient): + return '@' in recipient + + def send(self, recipient, message): + self.log.info( + 'Connecting to SMTP server %s:%s' % (self._host, self._port)) + + # we construct a defer to pass to the ESMTPSenderFactory + d = defer.Deferred() + # we don't pass an ssl context factory to the ESMTPSenderFactory + # because ssl will be handled by reactor.connectSSL() below. + factory = smtp.ESMTPSenderFactory( + "", # username is blank, no client auth here + "", # password is blank, no client auth here + self._from_address, + recipient.dest.addrstr, + StringIO(message), + d, + heloFallback=True, + requireAuthentication=False, + requireTransportSecurity=True) + factory.domain = bytes('leap.bitmask.mail-' + __version__) + reactor.connectSSL( + self._host, self._port, factory, + contextFactory=SSLContextFactory(self._key, self._key)) + d.addCallback(lambda result: result[1][0][0]) + d.addErrback(self._send_errback) + return d + + def _send_errback(self, failure): + raise SendError(failure.getErrorMessage()) + + +class SSLContextFactory(ssl.ClientContextFactory): + def __init__(self, cert, key): + self.cert = cert + self.key = key + + def getContext(self): + # FIXME -- we should use sslv23 to allow for tlsv1.2 + # and, if possible, explicitely disable sslv3 clientside. + # Servers should avoid sslv3 + self.method = SSL.TLSv1_METHOD # SSLv23_METHOD + ctx = ssl.ClientContextFactory.getContext(self) + ctx.use_certificate_file(self.cert) + ctx.use_privatekey_file(self.key) + return ctx diff --git a/src/leap/bitmask/mail/outgoing/service.py b/src/leap/bitmask/mail/outgoing/service.py index 4f39691b..a48e363c 100644 --- a/src/leap/bitmask/mail/outgoing/service.py +++ b/src/leap/bitmask/mail/outgoing/service.py @@ -1,6 +1,6 @@ # -*- coding: utf-8 -*- # outgoing/service.py -# Copyright (C) 2013-2015 LEAP +# Copyright (C) 2013-2017 LEAP # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by @@ -21,7 +21,6 @@ OutgoingMail module. The OutgoingMail class allows to send mail, and encrypts/signs it if needed. """ -import os.path import re from StringIO import StringIO from copy import deepcopy @@ -31,19 +30,14 @@ from email.mime.application import MIMEApplication from email.mime.multipart import MIMEMultipart from email.mime.text import MIMEText -from OpenSSL import SSL - from twisted.mail import smtp -from twisted.internet import reactor from twisted.internet import defer +from twisted.python.failure import Failure from twisted.logger import Logger -from twisted.protocols.amp import ssl from leap.common.check import leap_assert_type, leap_assert from leap.common.events import emit_async, catalog -from leap.bitmask import __version__ from leap.bitmask.keymanager.errors import KeyNotFound, KeyAddressMismatch -from leap.bitmask.mail import errors from leap.bitmask.mail.utils import validate_address from leap.bitmask.mail.rfc3156 import MultipartEncrypted from leap.bitmask.mail.rfc3156 import MultipartSigned @@ -57,39 +51,6 @@ from leap.bitmask.mail.rfc3156 import PGPEncrypted # of IService -class SSLContextFactory(ssl.ClientContextFactory): - def __init__(self, cert, key): - self.cert = cert - self.key = key - - def getContext(self): - # FIXME -- we should use sslv23 to allow for tlsv1.2 - # and, if possible, explicitely disable sslv3 clientside. - # Servers should avoid sslv3 - self.method = SSL.TLSv1_METHOD # SSLv23_METHOD - ctx = ssl.ClientContextFactory.getContext(self) - ctx.use_certificate_file(self.cert) - ctx.use_privatekey_file(self.key) - return ctx - - -def outgoingFactory(userid, keymanager, opts, check_cert=True, bouncer=None): - - cert = unicode(opts.cert) - key = unicode(opts.key) - hostname = str(opts.hostname) - port = opts.port - - if check_cert: - if not os.path.isfile(cert): - raise errors.ConfigurationError( - 'No valid SMTP certificate could be found for %s!' % userid) - - return OutgoingMail( - str(userid), keymanager, cert, key, hostname, port, - bouncer) - - class OutgoingMail(object): """ Sends Outgoing Mail, encrypting and signing if needed. @@ -97,8 +58,7 @@ class OutgoingMail(object): log = Logger() - def __init__(self, from_address, keymanager, cert, key, host, port, - bouncer=None): + def __init__(self, from_address, keymanager, bouncer=None): """ Initialize the outgoing mail service. @@ -106,39 +66,25 @@ class OutgoingMail(object): :type from_address: str :param keymanager: A KeyManager for retrieving recipient's keys. :type keymanager: leap.common.keymanager.KeyManager - :param cert: The client certificate for SSL authentication. - :type cert: str - :param key: The client private key for SSL authentication. - :type key: str - :param host: The hostname of the remote SMTP server. - :type host: str - :param port: The port of the remote SMTP server. - :type port: int """ # assert params - leap_assert_type(from_address, str) + leap_assert_type(from_address, (str, unicode)) leap_assert('@' in from_address) # XXX it can be a zope.proxy too # leap_assert_type(keymanager, KeyManager) - leap_assert_type(host, str) - leap_assert(host != '') - leap_assert_type(port, int) - leap_assert(port is not 0) - leap_assert_type(cert, basestring) - leap_assert(cert != '') - leap_assert_type(key, basestring) - leap_assert(key != '') - - self._port = port - self._host = host - self._key = key - self._cert = cert self._from_address = from_address self._keymanager = keymanager self._bouncer = bouncer + self._senders = [] + + def add_sender(self, sender): + """ + Add an ISender to the outgoing service + """ + self._senders.append(sender) def send_message(self, raw, recipient): """ @@ -151,19 +97,26 @@ class OutgoingMail(object): :return: a deferred which delivers the message when fired """ d = self._maybe_encrypt_and_sign(raw, recipient) - d.addCallback(self._route_msg, raw) + d.addCallback(self._route_msg, recipient, raw) d.addErrback(self.sendError, raw) return d - def sendSuccess(self, smtp_sender_result): + def can_encrypt_for(self, recipient): + def cb(_): + return True + + def eb(failure): + failure.trap(KeyNotFound) + return False + + d = self._keymanager.get_key(recipient) + d.addCallbacks(cb, eb) + return d + + def sendSuccess(self, dest_addrstr): """ Callback for a successful send. - - :param smtp_sender_result: The result from the ESMTPSender from - _route_msg - :type smtp_sender_result: tuple(int, list(tuple)) """ - dest_addrstr = smtp_sender_result[1][0][0] fromaddr = self._from_address self.log.info('Message sent from %s to %s' % (fromaddr, dest_addrstr)) emit_async(catalog.SMTP_SEND_MESSAGE_SUCCESS, @@ -197,7 +150,7 @@ class OutgoingMail(object): else: failure.raiseException() - def _route_msg(self, encrypt_and_sign_result, raw): + def _route_msg(self, encrypt_and_sign_result, recipient, raw): """ Sends the msg using the ESMTPSenderFactory. @@ -206,32 +159,24 @@ class OutgoingMail(object): :type encrypt_and_sign_result: tuple """ message, recipient = encrypt_and_sign_result - self.log.info( - 'Connecting to SMTP server %s:%s' % (self._host, self._port)) msg = message.as_string(False) - # we construct a defer to pass to the ESMTPSenderFactory - d = defer.Deferred() - d.addCallback(self.sendSuccess) - d.addErrback(self.sendError, raw) - # we don't pass an ssl context factory to the ESMTPSenderFactory - # because ssl will be handled by reactor.connectSSL() below. - factory = smtp.ESMTPSenderFactory( - "", # username is blank, no client auth here - "", # password is blank, no client auth here - self._from_address, - recipient.dest.addrstr, - StringIO(msg), - d, - heloFallback=True, - requireAuthentication=False, - requireTransportSecurity=True) - factory.domain = bytes('leap.bitmask.mail-' + __version__) + d = None + for sender in self._senders: + if sender.can_send(recipient.dest.addrstr): + self.log.debug('Sending message to %s with: %s' + % (recipient, str(sender))) + d = sender.send(recipient, msg) + break + + if d is None: + return self.sendError(Failure(), raw) + emit_async(catalog.SMTP_SEND_MESSAGE_START, self._from_address, recipient.dest.addrstr) - reactor.connectSSL( - self._host, self._port, factory, - contextFactory=SSLContextFactory(self._cert, self._key)) + d.addCallback(self.sendSuccess) + d.addErrback(self.sendError, raw) + return d def _maybe_encrypt_and_sign(self, raw, recipient, fetch_remote=True): """ diff --git a/src/leap/bitmask/mail/smtp/gateway.py b/src/leap/bitmask/mail/smtp/gateway.py index 08d59e11..4dfccd1a 100644 --- a/src/leap/bitmask/mail/smtp/gateway.py +++ b/src/leap/bitmask/mail/smtp/gateway.py @@ -38,7 +38,7 @@ from zope.interface import implementer from twisted.cred.portal import Portal, IRealm from twisted.mail import smtp from twisted.mail.imap4 import LOGINCredentials, PLAINCredentials -from twisted.internet import defer, protocol +from twisted.internet import protocol from twisted.logger import Logger from leap.common.check import leap_assert_type @@ -47,9 +47,6 @@ from leap.bitmask.mail import errors from leap.bitmask.mail.cred import LocalSoledadTokenChecker from leap.bitmask.mail.utils import validate_address from leap.bitmask.mail.rfc3156 import RFC3156CompliantGenerator -from leap.bitmask.mail.outgoing.service import outgoingFactory -from leap.bitmask.mail.smtp.bounces import bouncerFactory -from leap.bitmask.keymanager.errors import KeyNotFound # replace email generator with a RFC 3156 compliant one. generator.Generator = RFC3156CompliantGenerator @@ -62,81 +59,30 @@ class LocalSMTPRealm(object): _encoding = 'utf-8' - def __init__(self, keymanager_sessions, soledad_sessions, sendmail_opts, - encrypted_only=False): - """ - :param keymanager_sessions: a dict-like object, containing instances - of a Keymanager objects, indexed by - userid. - """ - self._keymanager_sessions = keymanager_sessions - self._soledad_sessions = soledad_sessions - self._sendmail_opts = sendmail_opts + def __init__(self, outgoing_sessions, encrypted_only=False): + self._outgoing_sessions = outgoing_sessions self.encrypted_only = encrypted_only def requestAvatar(self, avatarId, mind, *interfaces): + if smtp.IMessageDelivery not in interfaces: + raise NotImplementedError(self, interfaces) if isinstance(avatarId, str): avatarId = avatarId.decode(self._encoding) - def gotKeymanagerAndSoledad(result): - keymanager, soledad = result - d = bouncerFactory(soledad) - d.addCallback(lambda bouncer: (keymanager, soledad, bouncer)) - return d - - def getMessageDelivery(result): - keymanager, soledad, bouncer = result - # TODO use IMessageDeliveryFactory instead ? - # it could reuse the connections. - if smtp.IMessageDelivery in interfaces: - userid = avatarId - opts = self.getSendingOpts(userid) - - outgoing = outgoingFactory( - userid, keymanager, opts, bouncer=bouncer) - avatar = SMTPDelivery(userid, keymanager, self.encrypted_only, - outgoing) - - return (smtp.IMessageDelivery, avatar, - getattr(avatar, 'logout', lambda: None)) - - raise NotImplementedError(self, interfaces) - - d1 = self.lookupKeymanagerInstance(avatarId) - d2 = self.lookupSoledadInstance(avatarId) - d = defer.gatherResults([d1, d2]) - d.addCallback(gotKeymanagerAndSoledad) - d.addCallback(getMessageDelivery) - return d + outgoing = self.lookupOutgoingInstance(avatarId) + avatar = SMTPDelivery(avatarId, self.encrypted_only, outgoing) + return (smtp.IMessageDelivery, avatar, + getattr(avatar, 'logout', lambda: None)) - def lookupKeymanagerInstance(self, userid): + def lookupOutgoingInstance(self, userid): try: - keymanager = self._keymanager_sessions[userid] + outgoing = self._outgoing_sessions[userid] except: raise errors.AuthenticationError( - 'No keymanager session found for user %s. Is it authenticated?' + 'No outgoing session found for user %s. Is it authenticated?' % userid) - # XXX this should return the instance after whenReady callback - return defer.succeed(keymanager) - - def lookupSoledadInstance(self, userid): - try: - soledad = self._soledad_sessions[userid] - except: - raise errors.AuthenticationError( - 'No soledad session found for user %s. Is it authenticated?' - % userid) - # XXX this should return the instance after whenReady callback - return defer.succeed(soledad) - - def getSendingOpts(self, userid): - try: - opts = self._sendmail_opts[userid] - except KeyError: - raise errors.ConfigurationError( - 'No sendingMail options found for user %s' % userid) - return opts + return outgoing class SMTPTokenChecker(LocalSoledadTokenChecker): @@ -155,11 +101,9 @@ class LEAPInitMixin(object): A Mixin that takes care of initialization of all the data needed to access LEAP sessions. """ - def __init__(self, soledad_sessions, keymanager_sessions, sendmail_opts, + def __init__(self, outgoing_sessions, soledad_sessions, encrypted_only=False): - realm = LocalSMTPRealm( - keymanager_sessions, soledad_sessions, sendmail_opts, - encrypted_only) + realm = LocalSMTPRealm(outgoing_sessions, encrypted_only) portal = Portal(realm) checker = SMTPTokenChecker(soledad_sessions) @@ -177,12 +121,9 @@ class LocalSMTPServer(smtp.ESMTP, LEAPInitMixin): # TODO: implement Queue using twisted.mail.mail.MailService - def __init__(self, soledads, keyms, sendmailopts, *args, **kw): - encrypted_only = kw.pop('encrypted_only', False) - - LEAPInitMixin.__init__(self, soledads, keyms, sendmailopts, - encrypted_only) - smtp.ESMTP.__init__(self, *args, **kw) + def __init__(self, outgoings, soledads, encrypted_only=False): + LEAPInitMixin.__init__(self, outgoings, soledads, encrypted_only) + smtp.ESMTP.__init__(self) # TODO implement retries -- see smtp.SenderMixin @@ -196,17 +137,14 @@ class SMTPFactory(protocol.ServerFactory): timeout = 600 encrypted_only = False - def __init__(self, soledad_sessions, keymanager_sessions, sendmail_opts, - deferred=None, retries=3): - + def __init__(self, outgoing_sessions, soledad_sessions, deferred=None, + retries=3): + self._outgoing_sessions = outgoing_sessions self._soledad_sessions = soledad_sessions - self._keymanager_sessions = keymanager_sessions - self._sendmail_opts = sendmail_opts def buildProtocol(self, addr): - p = self.protocol( - self._soledad_sessions, self._keymanager_sessions, - self._sendmail_opts, encrypted_only=self.encrypted_only) + p = self.protocol(self._outgoing_sessions, self._soledad_sessions, + encrypted_only=self.encrypted_only) p.factory = self p.host = LOCAL_FQDN p.challengers = {"LOGIN": LOGINCredentials, "PLAIN": PLAINCredentials} @@ -226,14 +164,12 @@ class SMTPDelivery(object): log = Logger() - def __init__(self, userid, keymanager, encrypted_only, outgoing_mail): + def __init__(self, userid, encrypted_only, outgoing_mail): """ Initialize the SMTP delivery object. :param userid: The user currently logged in :type userid: unicode - :param keymanager: A Key Manager from where to get recipients' public - keys. :param encrypted_only: Whether the SMTP gateway should send unencrypted mail or not. :type encrypted_only: bool @@ -241,8 +177,7 @@ class SMTPDelivery(object): :type outgoing_mail: leap.bitmask.mail.outgoing.service.OutgoingMail """ self._userid = userid - self._outgoing_mail = outgoing_mail - self._km = keymanager + self._outgoing = outgoing_mail self._encrypted_only = encrypted_only self._origin = None @@ -297,32 +232,28 @@ class SMTPDelivery(object): # try to find recipient's public key address = validate_address(user.dest.addrstr) - # verify if recipient key is available in keyring - def found(_): - self.log.debug('Accepting mail for %s...' % user.dest.addrstr) - emit_async(catalog.SMTP_RECIPIENT_ACCEPTED_ENCRYPTED, - self._userid, user.dest.addrstr) - - def not_found(failure): - failure.trap(KeyNotFound) - - # if key was not found, check config to see if will send anyway - if self._encrypted_only: + def verify_if_can_encrypt_for_recipient(can_encrypt): + if can_encrypt: + self.log.debug('Accepting mail for %s...' % user.dest.addrstr) + emit_async(catalog.SMTP_RECIPIENT_ACCEPTED_ENCRYPTED, + self._userid, user.dest.addrstr) + elif self._encrypted_only: emit_async(catalog.SMTP_RECIPIENT_REJECTED, self._userid, user.dest.addrstr) raise smtp.SMTPBadRcpt(user.dest.addrstr) - self.log.warn( - 'Warning: will send an unencrypted message (because ' - '"encrypted_only" is set to False).') - emit_async( - catalog.SMTP_RECIPIENT_ACCEPTED_UNENCRYPTED, - self._userid, user.dest.addrstr) + else: + self.log.warn( + 'Warning: will send an unencrypted message (because ' + '"encrypted_only" is set to False).') + emit_async( + catalog.SMTP_RECIPIENT_ACCEPTED_UNENCRYPTED, + self._userid, user.dest.addrstr) def encrypt_func(_): - return lambda: EncryptedMessage(user, self._outgoing_mail) + return lambda: EncryptedMessage(user, self._outgoing) - d = self._km.get_key(address) - d.addCallbacks(found, not_found) + d = self._outgoing.can_encrypt_for(address) + d.addCallback(verify_if_can_encrypt_for_recipient) d.addCallback(encrypt_func) return d @@ -379,7 +310,7 @@ class EncryptedMessage(object): self._user = user self._lines = [] - self._outgoing_mail = outgoing_mail + self._outgoing = outgoing_mail def lineReceived(self, line): """ @@ -402,7 +333,7 @@ class EncryptedMessage(object): self._lines.append('') # add a trailing newline raw_mail = '\r\n'.join(self._lines) - return self._outgoing_mail.send_message(raw_mail, self._user) + return self._outgoing.send_message(raw_mail, self._user) def connectionLost(self): """ diff --git a/src/leap/bitmask/mail/smtp/service.py b/src/leap/bitmask/mail/smtp/service.py index 6fd000ce..788b2791 100644 --- a/src/leap/bitmask/mail/smtp/service.py +++ b/src/leap/bitmask/mail/smtp/service.py @@ -31,16 +31,15 @@ log = Logger() SMTP_PORT = 2013 -def run_service(soledad_sessions, keymanager_sessions, sendmail_opts, - port=SMTP_PORT, factory=None): +def run_service(outgoing_sessions, soledad_sessions, port=SMTP_PORT, + factory=None): """ Main entry point to run the service from the client. + :param outgoing_sessions: a dict-like object, containing instances + of outgoing, indexed by userid. :param soledad_sessions: a dict-like object, containing instances of a Store (soledad instances), indexed by userid. - :param keymanager_sessions: a dict-like object, containing instances - of Keymanager, indexed by userid. - :param sendmail_opts: a dict-like object of sendmailOptions. :param factory: a factory for the protocol that will listen in the given port @@ -49,8 +48,7 @@ def run_service(soledad_sessions, keymanager_sessions, sendmail_opts, :rtype: tuple """ if not factory: - factory = SMTPFactory(soledad_sessions, keymanager_sessions, - sendmail_opts) + factory = SMTPFactory(outgoing_sessions, soledad_sessions) try: interface = "localhost" diff --git a/src/leap/bitmask/mail/testing/smtp.py b/src/leap/bitmask/mail/testing/smtp.py index 834433f3..36628187 100644 --- a/src/leap/bitmask/mail/testing/smtp.py +++ b/src/leap/bitmask/mail/testing/smtp.py @@ -2,7 +2,6 @@ from twisted.mail import smtp from leap.bitmask.mail.smtp.gateway import SMTPFactory, LOCAL_FQDN from leap.bitmask.mail.smtp.gateway import SMTPDelivery -from leap.bitmask.mail.outgoing.service import outgoingFactory TEST_USER = u'anotheruser@leap.se' @@ -11,21 +10,12 @@ class UnauthenticatedSMTPServer(smtp.SMTP): encrypted_only = False - def __init__(self, soledads, keyms, opts, encrypted_only=False): + def __init__(self, outgoing_s, soledad_s, encrypted_only=False): smtp.SMTP.__init__(self) userid = TEST_USER - keym = keyms[userid] - - class Opts: - cert = '/tmp/cert' - key = '/tmp/cert' - hostname = 'remote' - port = 666 - - outgoing = outgoingFactory( - userid, keym, Opts, check_cert=False) - avatar = SMTPDelivery(userid, keym, encrypted_only, outgoing) + outgoing = outgoing_s[userid] + avatar = SMTPDelivery(userid, encrypted_only, outgoing) self.delivery = avatar def validateFrom(self, helo, origin): @@ -42,10 +32,8 @@ class UnauthenticatedSMTPFactory(SMTPFactory): encrypted_only = False -def getSMTPFactory(soledad_s, keymanager_s, sendmail_opts, - encrypted_only=False): +def getSMTPFactory(outgoing_s, soledad_s, encrypted_only=False): factory = UnauthenticatedSMTPFactory factory.encrypted_only = encrypted_only - proto = factory( - soledad_s, keymanager_s, sendmail_opts).buildProtocol(('127.0.0.1', 0)) + proto = factory(outgoing_s, soledad_s).buildProtocol(('127.0.0.1', 0)) return proto |