def test_reply_to_encrypted(self, bcmd, ac_sender, linematch):
send_adr = ac_sender.adr
msg = mime.gen_mail_msg(
From=send_adr, To=[bcmd.bot_adr],
Autocrypt=ac_sender.ac_headerval,
Subject="hello", _dto=True)
out = bcmd.run_ok(["bot-reply"], input=msg.as_string())
reply_msg = mime.parse_message_from_string(out)
ac_sender.process_incoming(reply_msg)
msg2 = mime.gen_mail_msg(
From=send_adr, To=[bcmd.bot_adr],
Autocrypt=ac_sender.ac_headerval,
Subject="encrypted", _dto=True)
r = ac_sender.encrypt_mime(msg2, [bcmd.bot_adr])
out2 = bcmd.run_ok(["bot-reply"], input=r.enc_msg.as_string())
enc_reply_msg = mime.parse_message_from_string(out2)
ac_sender.process_incoming(enc_reply_msg)
decrypted = ac_sender.decrypt_mime(enc_reply_msg)
body = decode_body(decrypted.dec_msg)
print(body)
linematch(body, """
*processed*account*default*
""")
assert "no Autocrypt header" not in body
assert "prefer_encrypt=nopreference" in body
assert "recommendation is encrypt" in body
def test_parse_incoming_mails_replace_by_date(self, account_maker):
acc1, acc2, acc3 = account_maker(), account_maker(), account_maker()
addr = acc1.addr
msg2 = mime.gen_mail_msg(From=addr,
To=["*****@*****.**"],
Autocrypt=acc3.make_ac_header(addr),
Date='Thu, 16 Feb 2017 15:00:00 -0000')
msg1 = mime.gen_mail_msg(From=addr,
To=["*****@*****.**"],
Autocrypt=acc2.make_ac_header(addr),
Date='Thu, 16 Feb 2017 13:00:00 -0000')
r = acc1.process_incoming(msg2)
assert r.account.get_peerstate(
addr).public_keyhandle == acc3.ownstate.keyhandle
r2 = acc1.process_incoming(msg1)
assert r2.peerstate.public_keyhandle == \
acc3.ownstate.keyhandle
assert r2.msg_date < r.msg_date
msg3 = mime.gen_mail_msg(From="Alice <%s>" % addr,
To=["*****@*****.**"],
_dto=True,
Date='Thu, 16 Feb 2017 17:00:00 -0000')
r3 = acc1.process_incoming(msg3)
assert "no valid" in r3.pah.error
assert r3.msg_date > r2.msg_date
assert r3.peerstate.last_seen == r3.msg_date
assert r3.peerstate.last_seen > r.peerstate.autocrypt_timestamp
def test_get_delivered_to():
msg = mime.gen_mail_msg(From="*****@*****.**", To=["*****@*****.**"], _dto=True)
assert mime.get_delivered_to(msg) == "*****@*****.**"
msg = mime.gen_mail_msg(From="*****@*****.**", To=["*****@*****.**"], _dto=False)
assert mime.get_delivered_to(msg, "*****@*****.**") == "*****@*****.**"
with pytest.raises(ValueError):
mime.get_delivered_to(msg)
def test_parse_incoming_mails_replace(self, account_maker):
acc1, acc2, acc3 = account_maker(), account_maker(), account_maker()
msg1 = mime.gen_mail_msg(From=acc1.addr,
To=[acc2.addr],
Autocrypt=acc2.make_ac_header(acc1.addr))
r = acc1.process_incoming(msg1)
assert r.peerstate.public_keyhandle == acc2.ownstate.keyhandle
msg2 = mime.gen_mail_msg(From=acc1.addr,
To=[acc2.addr],
Autocrypt=acc3.make_ac_header(acc1.addr))
r2 = acc1.process_incoming(msg2)
assert r2.peerstate.public_keyhandle == acc3.ownstate.keyhandle
def test_parse_incoming_mail_broken_date_header(self, account_maker):
addr = "*****@*****.**"
acc1 = account_maker()
msg = mime.gen_mail_msg(From=addr, To=["*****@*****.**"], Date="l1k2j3")
r = acc1.process_incoming(msg)
assert r.pah.error
assert r.msg_date == 0.0
def test_encrypted_if_mutual(self, bcmd, ac_sender, linematch):
bcmd.run_ok(["mod-account", "default", "--prefer-encrypt=mutual"])
ac_sender.modify(prefer_encrypt='mutual')
ac_sender.ac_headerval = ac_sender.make_ac_header(ac_sender.adr)
send_adr = ac_sender.adr
msg = mime.gen_mail_msg(
From=send_adr, To=[bcmd.bot_adr],
Autocrypt=ac_sender.ac_headerval,
Subject="hello", _dto=True)
out = bcmd.run_ok(["bot-reply"], input=msg.as_string())
reply_msg = mime.parse_message_from_string(out)
assert reply_msg["Subject"] == "Re: " + msg["Subject"]
assert reply_msg["From"] == bcmd.bot_adr
assert reply_msg["To"] == msg["From"]
assert reply_msg["Autocrypt"]
r = mime.parse_ac_headervalue(reply_msg["Autocrypt"])
assert r.addr == bcmd.bot_adr
assert r.keydata
ac_sender.process_incoming(reply_msg)
decrypted = ac_sender.decrypt_mime(reply_msg)
body = decode_body(decrypted.dec_msg)
linematch(body, """
*processed*account*default*
""")
assert "no Autocrypt header" not in body
assert "prefer_encrypt=mutual" in body
assert "recommendation is encrypt" in body
print(body)
def test_reply_with_autocrypt(self, bcmd, ac_sender, linematch):
send_adr = ac_sender.adr
msg = mime.gen_mail_msg(From=send_adr,
To=[bcmd.bot_adr],
Autocrypt=ac_sender.ac_headerval,
Subject="hello",
_dto=True)
out = bcmd.run_ok(["bot-reply"], input=msg.as_string())
reply_msg = mime.parse_message_from_string(out)
linematch(decode_body(reply_msg), """
*processed*account*default*
""")
assert reply_msg["Subject"] == "Re: " + msg["Subject"]
assert reply_msg["From"] == bcmd.bot_adr
assert reply_msg["To"] == msg["From"]
assert reply_msg["Autocrypt"]
r = mime.parse_ac_headervalue(reply_msg["Autocrypt"])
assert r.addr == bcmd.bot_adr
assert r.keydata
body = decode_body(reply_msg)
assert "no Autocrypt header" not in body
assert "recommendation is available" in body
print(body)
def test_send_reply(self, smtpserver, bcmd, ac_sender, with_ac, linematch):
host, port = smtpserver.addr[:2]
Autocrypt = None if not with_ac else ac_sender.ac_headerval
msg = mime.gen_mail_msg(
From=ac_sender.adr, To=[bcmd.bot_adr],
MessageID=mime.make_msgid("5" * 50), # long MessageID
Autocrypt=Autocrypt, Subject="hello", _dto=True)
bcmd.run_ok(["bot-reply", "--smtp={},{}".format(host, port)],
input=msg.as_string())
assert len(smtpserver.outbox) == 1
msg2 = smtpserver.outbox[0]
assert msg2["To"] == msg["From"]
assert msg2["From"] == msg["To"]
assert msg2["In-Reply-To"] == msg["Message-ID"]
assert msg["Subject"] in msg2["Subject"]
body = decode_body(msg2)
linematch(body, """
*Got your mail*
*Message-ID*{}*
""".format(msg["Message-ID"][:20]))
if with_ac:
linematch(body, """
*processed incoming*
*{senderadr}*{senderkeyhandle}*
""".format(
senderadr=mime.parse_email_addr(ac_sender.adr),
senderkeyhandle=ac_sender.ownstate.keyhandle,
))
def test_ignore_incoming_mail_multiple_from(self, account_maker):
sender, recipient = account_maker(), account_maker()
msg = mime.gen_mail_msg(From=','.join([sender.addr, "*****@*****.**"]),
To=[recipient.addr],
Autocrypt=sender.make_ac_header(sender.addr))
r = recipient.process_incoming(msg)
assert r.pah.error == "Ignoring message with more than one address in From header."
def send_no_ac_mail(sender, recipient, Date=None):
mail = mime.gen_mail_msg(
From=sender.addr,
To=[recipient.addr],
Date=get_testdate(Date),
)
recipient.process_incoming(mail)
def test_parse_incoming_mail_broken_ac_header(self, account_maker):
acc1 = account_maker()
msg = mime.gen_mail_msg(From=acc1.addr,
To=[],
Autocrypt="Autocrypt: to=123; key=12312k3")
r = acc1.process_incoming(msg)
assert r.pah.error
assert r.msg_date
def send_enc_ac_mail(sender, recipients):
addrs = [r.addr for r in recipients]
msg = mime.gen_mail_msg(From=sender.addr,
To=addrs,
Autocrypt=sender.make_ac_header(sender.addr))
r = sender.encrypt_mime(msg, addrs)
for rec in recipients:
rec.process_incoming(r.enc_msg)
def do_gen_mail(From="*****@*****.**", body=None):
msg = mime.gen_mail_msg(
From=From, To=["*****@*****.**"],
Subject="test mail {} [{}]".format(next(counter), nid),
)
if body is not None:
msg.set_payload(body)
return msg
def test_empty_subject(self, bcmd, ac_sender):
send_adr = ac_sender.adr
msg = mime.gen_mail_msg(
From=send_adr, To=[bcmd.bot_adr],
Autocrypt=ac_sender.ac_headerval,
Subject=None, _dto=True)
bcmd.run_ok(["bot-reply"], input=msg.as_string())
def test_parse_incoming_msg_twice_same_entries(self, account_maker):
acc1, acc2 = account_maker(), account_maker()
msg1 = mime.gen_mail_msg(From=acc1.addr,
To=[acc2.addr],
Autocrypt=acc1.make_ac_header(acc1.addr))
msg2 = mime.gen_mail_msg(From=acc1.addr,
To=[acc2.addr],
Autocrypt=acc1.make_ac_header(acc1.addr))
r = acc2.process_incoming(msg1)
assert r.peerstate.public_keyhandle == acc1.ownstate.keyhandle
assert r.peerstate._latest_msg_entry().msg_id == msg1["Message-Id"]
r = acc2.process_incoming(msg2)
assert r.peerstate._latest_msg_entry().msg_id == msg2["Message-Id"]
i = len(r.peerstate._chain)
r = acc2.process_incoming(msg1, ignore_existing=False)
r = acc2.process_incoming(msg2, ignore_existing=False)
assert i == len(r.peerstate._chain)
def test_process_incoming_no_autocrypt(self, mycmd):
mycmd.run_ok(["add-account", "[email protected]"])
mycmd.run_ok(["peerstate", "*****@*****.**"])
msg = mime.gen_mail_msg(From="Alice <*****@*****.**>", To=["*****@*****.**"], _dto=True)
mycmd.run_ok(["process-incoming"], """
*processed*default*no*Autocrypt*header*
""", input=msg.as_string())
mycmd.run_ok(["peerstate", "*****@*****.**"])
def gen_ac_mail_msg(acc1, acc2, payload=None, charset=None, Date=None):
return mime.gen_mail_msg(
From=acc1.addr,
To=[acc2.addr],
Autocrypt=acc1.make_ac_header(acc1.addr),
payload=payload,
charset=charset,
Date=Date,
)
def test_parse_incoming_mail_unicode_from(self, account_maker):
addr = 'x@k\366nig.de'
acc1 = account_maker()
msg = mime.gen_mail_msg(
From=addr,
To=["*****@*****.**"],
)
r = acc1.process_incoming(msg)
assert r.pah.error
def test_parse_incoming_mail_broken_keydata(self, account_maker, keydata):
addr = "*****@*****.**"
acc1 = account_maker()
msg = mime.gen_mail_msg(From=addr,
To=["*****@*****.**"],
Autocrypt="addr={}; keydata={}".format(
addr, keydata))
r = acc1.process_incoming(msg)
assert r.pah.error
def test_get_recommendation(self, account_maker):
sender, recipient = account_maker(), account_maker()
msg1 = mime.gen_mail_msg(From=sender.addr,
To=[recipient.addr],
Autocrypt=sender.make_ac_header(sender.addr))
recipient.process_incoming(msg1)
recommend = recipient.get_recommendation({sender.addr})
assert recommend.ui_recommendation() == 'available'
assert recommend.target_keyhandles()[
sender.addr] == sender.ownstate.keyhandle
def test_reply_with_cc_bot(self, bcmd, ac_sender):
send_adr = ac_sender.adr
msg = mime.gen_mail_msg(
From=send_adr, To=["*****@*****.**"],
Cc=[bcmd.bot_adr],
Autocrypt=ac_sender.ac_headerval,
Subject="hello", _dto=bcmd.bot_adr)
out = bcmd.run_ok(["bot-reply"], input=msg.as_string())
assert not out
def test_accept_incoming_mail_with_at_in_from_realname(
self, account_maker):
sender, recipient = account_maker(), account_maker()
msg = mime.gen_mail_msg(
From=email.utils.formataddr([sender.addr, sender.addr]),
To=[recipient.addr],
Autocrypt=sender.make_ac_header(sender.addr),
)
r = recipient.process_incoming(msg)
assert r.pah.error is None
def gen_ac_mail_msg(sender, recipients, payload=None, charset=None, Date=None):
if isinstance(recipients, Account):
recipients = [recipients]
return mime.gen_mail_msg(
From=sender.addr,
To=[rec.addr for rec in recipients],
Autocrypt=sender.make_ac_header(sender.addr),
payload=payload,
charset=charset,
Date=Date,
)
def test_reply_puts_to_addresses_to_cc(self, bcmd, ac_sender, linematch):
send_adr = ac_sender.adr
msg = mime.gen_mail_msg(
From=send_adr, To=["*****@*****.**", bcmd.bot_adr],
Autocrypt=ac_sender.ac_headerval,
Subject="hello", _dto=bcmd.bot_adr)
out = bcmd.run_ok(["bot-reply"], input=msg.as_string())
reply_msg = mime.parse_message_from_string(out)
assert reply_msg["To"] == send_adr
assert reply_msg["Cc"] == "*****@*****.**"
def test_reply_with_cc_and_to_bot(self, bcmd, ac_sender):
send_adr = ac_sender.adr
msg = mime.gen_mail_msg(
From=send_adr, To=[bcmd.bot_adr],
Cc=['*****@*****.**'],
Autocrypt=ac_sender.ac_headerval,
Subject="hello", _dto=True)
out = bcmd.run_ok(["bot-reply"], input=msg.as_string())
reply_msg = mime.parse_message_from_string(out)
assert reply_msg["To"] == send_adr
assert reply_msg["Cc"] == msg["Cc"]
def test_reply_no_autocrypt(self, bcmd):
adr = "*****@*****.**"
msg = mime.gen_mail_msg(
From=adr, To=[bcmd.bot_adr],
Autocrypt=None, Subject="hello", _dto=True)
out = bcmd.run_ok(["bot-reply"], input=msg.as_string())
reply_msg = mime.parse_message_from_string(out)
assert reply_msg["Subject"] == "Re: " + msg["Subject"]
assert reply_msg["Autocrypt"]
body = decode_body(reply_msg)
print(body)
assert "no valid autocrypt" in body.lower()
def gen_noac_mail_msg(sender,
recipients,
payload=None,
charset=None,
Date=None,
_dto=False):
if isinstance(recipients, Account):
recipients = [recipients]
return mime.gen_mail_msg(
From=sender.addr,
To=[rec.addr for rec in recipients],
payload=payload,
charset=charset,
Date=Date,
_dto=_dto,
)
def test_reply_no_delivto(self, bcmd, ac_sender, linematch):
send_adr = ac_sender.adr
msg = mime.gen_mail_msg(
From=send_adr, To=[bcmd.bot_adr],
Subject="hello")
out = bcmd.run_ok(["bot-reply", "--fallback-delivto", bcmd.bot_adr],
input=msg.as_string())
reply_msg = mime.parse_message_from_string(out)
linematch(decode_body(reply_msg), """
*processed*account*default*
""")
assert reply_msg["Subject"] == "Re: " + msg["Subject"]
assert reply_msg["From"] == bcmd.bot_adr
assert reply_msg["To"] == msg["From"]
assert reply_msg["Autocrypt"]
def test_parse_incoming_mail_broken_from(self, account_maker):
acc1 = account_maker()
msg = mime.gen_mail_msg(From="", To=["*****@*****.**"])
r = acc1.process_incoming(msg)
assert r.pah.error
def send_ac_mail(sender, recipient, Date=None):
mail = mime.gen_mail_msg(From=sender.addr,
To=[recipient.addr],
Autocrypt=sender.make_ac_header(sender.addr),
Date=get_testdate(Date))
recipient.process_incoming(mail)
