def worker(self,incoming=False,outgoing=False,register=False,crypto=False,
once=False,dryrun=False,send=True,period=0):
import time, celery, socket, ssl
from kombu import Connection
from idapi.mails import save_mail, send_mails, get_mails, process_crypto, process_register
if not (incoming or outgoing or register or crypto):
raise CommandError('nothing to do')
conn = dummy_context()
if settings.BROKER_URL and incoming:
if settings.USE_CELERY:
conn = celery.current_app.pool.acquire(timeout=1)
else:
conn = Connection(settings.BROKER_URL,ssl=settings.BROKER_USE_SSL)
imap, smtp = {}, {} # connection cache
last_time = 0
with conn as conn:
self.connection = conn
while not self.terminated:
towait = period - (time.time() - last_time)
if towait>0: time.sleep(towait)
last_time = time.time()
if incoming:
get_mails(joint=True,connections=imap,notify=conn)
if outgoing:
send_mails(joint=True,connections=smtp)
if register:
process_register()
if crypto:
process_crypto(notify=conn)
if once: break
def worker(self,
incoming=False,
outgoing=False,
register=False,
crypto=False,
daemon=False,
once=False,
dryrun=False,
send=True,
period=0):
import time
from idapi.mails import save_mail, send_mails, get_mails, process_crypto, process_register
global worker_work
imap, smtp = {}, {} # connection cache
last_time = 0
while worker_work:
towait = period - (time.time() - last_time)
if towait > 0: time.sleep(towait)
last_time = time.time()
if incoming:
send_mails(joint=True, connections=imaps)
if outgoing:
send_mails(joint=True, connections=smtp)
if register:
process_register()
if crypto:
process_crypto()
if once: break
def worker(self,
incoming=False,
outgoing=False,
register=False,
crypto=False,
once=False,
dryrun=False,
send=True,
period=0):
import time, celery, socket, ssl
from kombu import Connection
from idapi.mails import save_mail, send_mails, get_mails, process_crypto, process_register
if not (incoming or outgoing or register or crypto):
raise CommandError('nothing to do')
conn = dummy_context()
if settings.BROKER_URL and incoming:
if settings.USE_CELERY:
conn = celery.current_app.pool.acquire(timeout=1)
else:
conn = Connection(settings.BROKER_URL,
ssl=settings.BROKER_USE_SSL)
imap, smtp = {}, {} # connection cache
last_time = 0
with conn as conn:
self.connection = conn
while not self.terminated:
towait = period - (time.time() - last_time)
if towait > 0: time.sleep(towait)
last_time = time.time()
if incoming:
get_mails(joint=True, connections=imap, notify=conn)
if outgoing:
send_mails(joint=True, connections=smtp)
if register:
process_register()
if crypto:
process_crypto(notify=conn)
if once: break
def test_registerkey(request,accounts,mails,bilateral,defect):
from accounts.models import Account
from idapi.models import Message, PublicKey
from idapi.mails import gnupg_init, get_mails, send_mails, update_keyrings, process_register
import email.mime.text
from kryptomime import create_mail
from kryptomime.pgp import find_gnupg_key
import tempfile
home = tempfile.mkdtemp()
gpg = gnupg_init(home)
update_keyrings(debug_gpg=gpg,debug_import=bilateral['gpg1'])
user = accounts['member1']
id1, id2 = bilateral['id1'], bilateral['id2']
key1 = find_gnupg_key(bilateral['gpg1'],sender)
key2 = find_gnupg_key(bilateral['gpg2'],receiver)
server, imapsend, imaprecv = mails
# id1=register, id2=member1
if defect=='unknown':
# unknown sender, should be rejected
unknown = 'unknown@localhost'
imapbad = server.add_account(unknown,keep=False)
msg = create_mail(unknown,sender,'register','register')
elif defect=='nokey':
# known sender, but forget key/signing
msg = create_mail(receiver,sender,'register','register')
else:
# known sender, return confirmation request
attach = id2.pubkey_attachment(key2)
msg = create_mail(receiver,sender,'register','register',attach=[attach])
assert server.send(msg)
assert len(imapsend)==1
get_mails(joint=True,debug=server,debug_gpg=gpg,keep=False)
process_register(debug_gpg=gpg)
send_mails(joint=True,debug=server,debug_gpg=gpg)
if defect=='unknown':
assert len(imapbad)==1
for mail, flags in imapbad:
mail, verified, result = id2.decrypt(mail,strict=False)
assert mail and result
assert not result['encrypted'] and result['signed'] and result['fingerprints']==[key1]
#print mail
# assert key1 attached
return
return #FIXME
assert len(imaprecv)==1
msg = None
for mail, flags in imaprecv:
mail, verified, result = id2.decrypt(mail,strict=False)
assert mail and result
assert result['signed'] and result['fingerprints']==[key1]
assert bool(result['encrypted']) == (defect!='nokey')
#print mail
msg = mail
# assert key1 attached
if defect=='nokey':
return
if defect=='badcode':
reply = create_mail(receiver,sender,'confirmation','bad code')
else:
body = msg.get_payload()
reply = '> '+'> '.join(body.splitlines(True))
reply = create_mail(receiver,sender,'Re: '+mail['subject'],reply)
reply = id2.encrypt(reply,sign=True)
assert server.send(reply)
assert len(imapsend)==1
get_mails(joint=True,debug=server,debug_gpg=gpg,keep=False)
process_register(debug_gpg=gpg)
send_mails(joint=True,debug=server,debug_gpg=gpg)
assert len(imaprecv)==1
for mail, flags in imaprecv:
mail, verified, result = id2.decrypt(mail,strict=False)
assert mail and result
assert result['encrypted'] and result['signed'] and result['fingerprints']==[key1]
#print mail
msg = mail
# assert key1 attached
if defect=='badcode':
return
if defect!='unverified':
key = user.publickeys.get(active=True)
key.trust=PublicKey.TRUSTED
key.save()
msg = create_mail(receiver,sender,'test','test')
msg = id2.encrypt(msg,sign=True)
assert server.send(reply)
assert len(imapsend)==1
get_mails(joint=True,debug=server,debug_gpg=gpg,keep=False)
# check verified = CONFIRMED/TRUST/...
# verifiyed key, receive
return
def test_send(request, accounts, tokens, mails, bilateral, client, defect):
from accounts.models import Account
from idapi.models import Message, PublicKey
from idapi.mails import send_mails, update_keyrings
from kryptomime.pgp import find_gnupg_key
user = accounts['member1']
token = tokens['member1']
#update_keyrings()
id1, id2 = bilateral['id1'], bilateral['id2']
key1 = find_gnupg_key(bilateral['gpg1'], sender)
key2 = find_gnupg_key(bilateral['gpg2'], receiver)
livemail = request.config.getoption('livemail')
if livemail: server = None
else: server, imapsend, imaprecv = mails
user.publickeys.create(active=True,
keytype=PublicKey.PGP,
trust=PublicKey.TRUSTED)
data = {
'identity': 'portal',
'content': {
'subject': 'hallo1',
'body': 'foö'
}
}
response, out = api(client, 'user/mails/', 'post', data, token=token)
assert response.status_code == 200
data = {
'identity': 'portal',
'content': {
'subject': 'hallo2',
'body': 'foo'
},
'sign': True
}
response, out = api(client, 'user/mails/', 'post', data, token=token)
assert response.status_code == 200
data = {
'identity': 'portal',
'content': {
'subject': 'hallo3',
'body': 'foo'
},
'sign': True,
'encrypt': True
}
response, out = api(client, 'user/mails/', 'post', data, token=token)
assert response.status_code == 200
send_mails(joint=True, debug=server, debug_gpg=bilateral['gpg1'])
if livemail:
server.close()
return
assert not len(imapsend) and len(imaprecv) == 3
for mail, flags in imaprecv:
mail, verified, result = id2.decrypt(mail)
assert mail and result
subj = mail.get('subject')
if subj == 'hallo1':
assert not result['encrypted'] and not result['signed']
else:
assert result['encrypted'] == (
subj == 'hallo3'
) and result['signed'] and result['fingerprints'] == [key1]
def do_send(attach, request, accounts, apps, tokens, mails, bilateral, client,
settings, defect):
from accounts.models import Account
from idapi.models import Message, PublicKey
from idapi.mails import send_mails, update_keyrings, send_mail, send_queue
from rest_framework.exceptions import ValidationError, PermissionDenied, MethodNotAllowed
from kryptomime.pgp import find_gnupg_key
from kryptomime.mail import mail_payload
queue = settings.EMAIL_QUEUE
user = accounts['member1']
token = tokens['member1']
app = apps['portal']
#update_keyrings()
id1, id2 = bilateral['id1'], bilateral['id2']
key1, key2 = bilateral['fingerprints']
gpg = bilateral['gpg1']
livemail = request.config.getoption('livemail')
if livemail: server = None
else: server, imapsend, imaprecv = mails
debug = dict(mail=server, gpg=gpg, broker={})
content = {'subject': 'hallo1', 'body': u'foö'}
data = {'identity': 'portal', 'content': content, 'acknowledge': True}
if attach:
msg = {'content': u'bär', 'content-type': 'text/plain'}
mfile = {'content': 'foo\r\nbar', 'filename': 'some.txt'}
data['parts'] = [msg, 'second', mfile]
else:
msg = data
excpt, error, estatus = None, None, None
if defect == 'client':
app = apps['debug']
excpt, estatus = PermissionDenied, 403
elif defect == 'noid':
del data['identity']
excpt, error = ValidationError, 'identity_missing'
elif defect == 'badid':
data['identity'] = 'bad'
excpt, error = ValidationError, 'identity_unknown'
elif defect == 'idperm':
data['identity'] = 'register'
excpt, error = ValidationError, 'identity_not_permitted'
elif defect == 'nosend':
data['identity'] = 'voting'
excpt, estatus = MethodNotAllowed, 405
elif defect == 'notemplate':
app = apps['voting']
data['identity'] = 'voting'
excpt, error = ValidationError, 'template_not_permitted'
elif defect == 'template':
data['template'] = 'bad'
excpt, error = ValidationError, 'template_unknown'
elif defect == 'content':
msg['content'] = ''
excpt, error = ValidationError, 'content_missing'
elif defect == 'ctype':
msg['content-type'] = 'image'
excpt, error = ValidationError, 'type_error'
elif defect == 'cparams':
msg['content-params'] = 'bad'
excpt, error = ValidationError, 'type_error'
elif defect == 'charset':
msg['content-charset'] = 'latin1'
if attach: msg['content'] = u'fo😃'
else: content['body'] = u'fo😃'
excpt, error = ValidationError, 'type_error'
elif defect == 'encoding':
msg['content-encoding'] = '7bit'
excpt, error = ValidationError, 'type_error'
elif defect == 'sign':
import copy # only top-level items are preserved
settings.EMAIL_IDS = copy.deepcopy(settings.EMAIL_IDS)
del settings.EMAIL_IDS['portal']['key']
excpt, error = ValidationError, 'signing'
if defect == 'encrypt':
excpt, error = ValidationError, 'pubkey_missing'
else:
user.publickeys.create(active=True,
keytype=PublicKey.PGP,
trust=PublicKey.TRUSTED,
fingerprint=key2)
def sendit(subject, sign, encrypt):
content['subject'] = subject
data['sign'], data['encrypt'] = sign, encrypt
if queue is True:
response, out = api(client,
'user/mails/',
'post',
data,
token=token)
if not excpt:
assert response.status_code == 200
else:
assert response.status_code == (estatus or 400)
assert not error or out['error'] == error
else:
if not excpt:
resp = send_mail(data, user, app, debug=debug)
if queue == 'crypto' and (sign or encrypt):
assert resp['status'] == 'queued'
send_queue(resp['msgid'], debug=debug)
response, out = api(client,
'user/mails/%s/' % resp['msgid'],
token=token)
assert response.status_code == 200 and out[
'status'] == 'sent'
assert out['encrypt'] == encrypt and out['sign'] == sign
else:
assert resp == dict(status='sent')
else:
with raises(excpt) as excinfo:
resp = send_mail(data, user, app, debug=debug)
assert not error or excinfo.value.detail['error'] == error
sendit('hallo1', True, True)
if excpt: return
sendit('hallo2', False, False)
sendit('hallo3', True, False)
sendit('hallo4', False, True)
if queue is True:
send_mails(joint=True, debug=debug)
if livemail:
server.close()
return
assert not len(imapsend) and len(imaprecv) == 4
for mail, flags in imaprecv:
mail, verified, result = id2.decrypt(mail)
assert mail and result
subj = mail['subject']
if attach:
assert mail_payload(mail) == [
u'foö', u'bär', u'second', u'foo\r\nbar'
]
else:
assert mail_payload(mail) == content['body']
assert result['encrypted'] == (subj in ('hallo1', 'hallo4'))
assert result['signed'] == (subj in ('hallo1', 'hallo3'))
if result['signed']: assert result['fingerprints'] == [key1]