def setUpFetcher(inbox_collection):
self.fetcher = IncomingMail(self.km, self._soledad,
inbox_collection, ADDRESS)
# The messages don't exist on soledad will fail on deletion
self.fetcher._delete_incoming_message = Mock(
return_value=defer.succeed(None))
def setUpIncomingMail(inbox):
incoming_mail = IncomingMail(
keymanager, soledad,
inbox, userid,
check_period=INCOMING_CHECK_PERIOD)
logger.debug('setting incoming mail service for %s' % userid)
incoming_mail.setName(userid)
self.addService(incoming_mail)
def setUpIncomingMail(inbox, acc):
incoming_mail = IncomingMail(keymanager,
soledad,
inbox,
userid,
check_period=INCOMING_CHECK_PERIOD)
incoming_mail.account = acc
self.log.debug('Setting Incoming Mail Service for %s' % userid)
incoming_mail.setName(userid)
self.addService(incoming_mail)
def setUpIncomingMail(inbox):
incoming_mail = IncomingMail(keymanager,
soledad,
inbox,
userid,
check_period=INCOMING_CHECK_PERIOD)
return incoming_mail
class IncomingMailTestCase(KeyManagerWithSoledadTestCase):
"""
Tests for the incoming mail parser
"""
NICKSERVER = "http://domain"
BODY = """
Governments of the Industrial World, you weary giants of flesh and steel, I
come from Cyberspace, the new home of Mind. On behalf of the future, I ask
you of the past to leave us alone. You are not welcome among us. You have
no sovereignty where we gather.
"""
EMAIL = """from: Test from SomeDomain <%(from)s>
to: %(to)s
subject: independence of cyberspace
%(body)s
""" % {
"from": ADDRESS_2,
"to": ADDRESS,
"body": BODY
}
def setUp(self):
cleanup_deferred_locks()
try:
del self._soledad
del self.km
except AttributeError:
pass
# pytest handles correctly the setupEnv for the class,
# but trial ignores it.
if not getattr(self, 'tempdir', None):
self.tempdir = tempfile.mkdtemp()
def getCollection(_):
adaptor = SoledadMailAdaptor()
store = self._soledad
adaptor.store = store
mbox_indexer = MailboxIndexer(store)
mbox_name = "INBOX"
mbox_uuid = str(uuid.uuid4())
def get_collection_from_mbox_wrapper(wrapper):
wrapper.uuid = mbox_uuid
return MessageCollection(adaptor,
store,
mbox_indexer=mbox_indexer,
mbox_wrapper=wrapper)
d = adaptor.initialize_store(store)
d.addCallback(lambda _: mbox_indexer.create_table(mbox_uuid))
d.addCallback(
lambda _: adaptor.get_or_create_mbox(store, mbox_name))
d.addCallback(get_collection_from_mbox_wrapper)
return d
def setUpFetcher(inbox_collection):
self.fetcher = IncomingMail(self.km, self._soledad,
inbox_collection, ADDRESS)
# The messages don't exist on soledad will fail on deletion
self.fetcher._delete_incoming_message = Mock(
return_value=defer.succeed(None))
d = KeyManagerWithSoledadTestCase.setUp(self)
d.addCallback(getCollection)
d.addCallback(setUpFetcher)
d.addErrback(log.err)
return d
def tearDown(self):
d = KeyManagerWithSoledadTestCase.tearDown(self)
return d
def testExtractOpenPGPHeader(self):
"""
Test the OpenPGP header key extraction
"""
KEYURL = "https://leap.se/key.txt"
OpenPGP = "id=12345678; url=\"%s\"; preference=signencrypt" % (
KEYURL, )
message = Parser().parsestr(self.EMAIL)
message.add_header("OpenPGP", OpenPGP)
self.fetcher._keymanager.fetch_key = Mock(
return_value=defer.succeed(None))
def fetch_key_called(ret):
self.fetcher._keymanager.fetch_key.assert_called_once_with(
ADDRESS_2, KEYURL)
d = self._create_incoming_email(message.as_string())
d.addCallback(lambda email: self._mock_soledad_get_from_index(
fields.JUST_MAIL_IDX, [email]))
d.addCallback(lambda _: self.fetcher.fetch())
d.addCallback(fetch_key_called)
return d
def testExtractOpenPGPHeaderInvalidUrl(self):
"""
Test the OpenPGP header key extraction
"""
KEYURL = "https://someotherdomain.com/key.txt"
OpenPGP = "id=12345678; url=\"%s\"; preference=signencrypt" % (
KEYURL, )
message = Parser().parsestr(self.EMAIL)
message.add_header("OpenPGP", OpenPGP)
self.fetcher._keymanager.fetch_key = Mock()
def fetch_key_called(ret):
self.assertFalse(self.fetcher._keymanager.fetch_key.called)
d = self._create_incoming_email(message.as_string())
d.addCallback(lambda email: self._mock_soledad_get_from_index(
fields.JUST_MAIL_IDX, [email]))
d.addCallback(lambda _: self.fetcher.fetch())
d.addCallback(fetch_key_called)
return d
def testExtractAttachedKey(self):
KEY = "-----BEGIN PGP PUBLIC KEY BLOCK-----\n..."
message = MIMEMultipart()
message.add_header("from", ADDRESS_2)
key = MIMEApplication("", "pgp-keys")
key.set_payload(KEY)
message.attach(key)
self.fetcher._keymanager.put_raw_key = Mock(
return_value=defer.succeed(None))
def put_raw_key_called(_):
self.fetcher._keymanager.put_raw_key.assert_called_once_with(
KEY, address=ADDRESS_2)
d = self._do_fetch(message.as_string())
d.addCallback(put_raw_key_called)
return d
def testExtractInvalidAttachedKey(self):
KEY = "-----BEGIN PGP PUBLIC KEY BLOCK-----\n..."
message = MIMEMultipart()
message.add_header("from", ADDRESS_2)
key = MIMEApplication("", "pgp-keys")
key.set_payload(KEY)
message.attach(key)
self.fetcher._keymanager.put_raw_key = Mock(
return_value=defer.fail(KeyAddressMismatch()))
def put_raw_key_called(_):
self.fetcher._keymanager.put_raw_key.assert_called_once_with(
KEY, address=ADDRESS_2)
d = self._do_fetch(message.as_string())
d.addCallback(put_raw_key_called)
d.addErrback(log.err)
return d
def testExtractAttachedKeyAndNotOpenPGPHeader(self):
KEY = "-----BEGIN PGP PUBLIC KEY BLOCK-----\n..."
KEYURL = "https://leap.se/key.txt"
OpenPGP = "id=12345678; url=\"%s\"; preference=signencrypt" % (
KEYURL, )
message = MIMEMultipart()
message.add_header("from", ADDRESS_2)
message.add_header("OpenPGP", OpenPGP)
key = MIMEApplication("", "pgp-keys")
key.set_payload(KEY)
message.attach(key)
self.fetcher._keymanager.put_raw_key = Mock(
return_value=defer.succeed(None))
self.fetcher._keymanager.fetch_key = Mock()
def put_raw_key_called(_):
self.fetcher._keymanager.put_raw_key.assert_called_once_with(
KEY, address=ADDRESS_2)
self.assertFalse(self.fetcher._keymanager.fetch_key.called)
d = self._do_fetch(message.as_string())
d.addCallback(put_raw_key_called)
return d
def testExtractOpenPGPHeaderIfInvalidAttachedKey(self):
KEY = "-----BEGIN PGP PUBLIC KEY BLOCK-----\n..."
KEYURL = "https://leap.se/key.txt"
OpenPGP = "id=12345678; url=\"%s\"; preference=signencrypt" % (
KEYURL, )
message = MIMEMultipart()
message.add_header("from", ADDRESS_2)
message.add_header("OpenPGP", OpenPGP)
key = MIMEApplication("", "pgp-keys")
key.set_payload(KEY)
message.attach(key)
self.fetcher._keymanager.put_raw_key = Mock(
return_value=defer.fail(KeyAddressMismatch()))
self.fetcher._keymanager.fetch_key = Mock()
def put_raw_key_called(_):
self.fetcher._keymanager.put_raw_key.assert_called_once_with(
KEY, address=ADDRESS_2)
self.fetcher._keymanager.fetch_key.assert_called_once_with(
ADDRESS_2, KEYURL)
d = self._do_fetch(message.as_string())
d.addCallback(put_raw_key_called)
return d
def testAddDecryptedHeader(self):
class DummyMsg():
def __init__(self):
self.headers = {}
def add_header(self, k, v):
self.headers[k] = v
msg = DummyMsg()
self.fetcher._add_decrypted_header(msg)
self.assertEquals(msg.headers['X-Leap-Encryption'], 'decrypted')
def testDecryptEmail(self):
self.fetcher._decryption_error = Mock()
self.fetcher._add_decrypted_header = Mock()
def create_encrypted_message(encstr):
message = Parser().parsestr(self.EMAIL)
newmsg = MultipartEncrypted('application/pgp-encrypted')
for hkey, hval in message.items():
newmsg.add_header(hkey, hval)
encmsg = MIMEApplication(encstr,
_subtype='octet-stream',
_encoder=lambda x: x)
encmsg.add_header('content-disposition',
'attachment',
filename='msg.asc')
# create meta message
metamsg = PGPEncrypted()
metamsg.add_header('Content-Disposition', 'attachment')
# attach pgp message parts to new message
newmsg.attach(metamsg)
newmsg.attach(encmsg)
return newmsg
def decryption_error_not_called(_):
self.assertFalse(self.fetcher._decryption_error.called,
"There was some errors with decryption")
def add_decrypted_header_called(_):
self.assertTrue(self.fetcher._add_decrypted_header.called,
"There was some errors with decryption")
d = self.km.encrypt(self.EMAIL, ADDRESS, sign=ADDRESS_2)
d.addCallback(create_encrypted_message)
d.addCallback(lambda message: self._do_fetch(message.as_string()))
d.addCallback(decryption_error_not_called)
d.addCallback(add_decrypted_header_called)
return d
def testValidateSignatureFromEncryptedEmailFromAppleMail(self):
enc_signed_file = os.path.join(HERE,
'rfc822.multi-encrypt-signed.message')
self.fetcher._add_verified_signature_header = Mock()
def add_verified_signature_header_called(_):
self.assertTrue(self.fetcher._add_verified_signature_header.called,
"There was some errors verifying signature")
with open(enc_signed_file) as f:
enc_signed_raw = f.read()
d = self._do_fetch(enc_signed_raw)
d.addCallback(add_verified_signature_header_called)
return d
def testListener(self):
self.called = False
def listener(uid):
self.called = True
def listener_called(_):
self.assertTrue(self.called)
self.fetcher.add_listener(listener)
d = self._do_fetch(self.EMAIL)
d.addCallback(listener_called)
return d
def _do_fetch(self, message):
d = self._create_incoming_email(message)
d.addCallback(lambda email: self._mock_soledad_get_from_index(
fields.JUST_MAIL_IDX, [email]))
d.addCallback(lambda _: self.fetcher.fetch())
return d
def _create_incoming_email(self, email_str):
email = SoledadDocument()
data = json.dumps({
"incoming": True,
"content": email_str
},
ensure_ascii=False)
def set_email_content(encr_data):
email.content = {
fields.INCOMING_KEY: True,
fields.ERROR_DECRYPTING_KEY: False,
ENC_SCHEME_KEY: EncryptionSchemes.PUBKEY,
ENC_JSON_KEY: encr_data
}
return email
d = self.km.encrypt(data, ADDRESS, fetch_remote=False)
d.addCallback(set_email_content)
return d
def _mock_soledad_get_from_index(self, index_name, value):
get_from_index = self._soledad.get_from_index
def soledad_mock(idx_name, *key_values):
if index_name == idx_name:
return defer.succeed(value)
return get_from_index(idx_name, *key_values)
self.fetcher._soledad.get_from_index = Mock(side_effect=soledad_mock)
def _create_incoming_mail_fetcher(self, keymanager, soledad, account,
user_mail):
inbox = yield account.callWhenReady(
lambda _: account.get_collection_by_mailbox('INBOX'))
defer.returnValue(
IncomingMail(keymanager.keymanager, soledad, inbox, user_mail))