def test_encrypt_with_multiple_recipients(self):
# create two keypairs
pub1, priv1 = utils.keygen(self.name, self.email, self.passphrase)
pub2, priv2 = utils.keygen(self.name, self.email, self.passphrase)
# encrypt file for both
encrypted = utils.encrypt(self.file, [pub1, pub2])
# check keypair one can decrypt
decrypted = utils.decrypt(encrypted, priv1, pub1, self.passphrase)
self.assertEquals(decrypted, self.message)
# check keypair two can decrypt
decrypted = utils.decrypt(encrypted, priv2, pub2, self.passphrase)
self.assertEquals(decrypted, self.message)
def share_file(self):
if 'form.submitted' in self.request.POST and form.validate():
passphrase = form.data['passphrase']
query_file = os.path.join(self.storage_dir, self.username, self.filename)
share_user = self.request.params['share_user']
with utils.db_session(self.dbmaker) as session:
owner = session.query(User).filter(User.username==self.username).one()
f = session.query(File).filter(File.name==self.filename).one()
u = session.query(User).filter(User.username==share_user).first()
if u is None:
del f.shared_users[:]
else:
for key in u.keys:
f.keys.append(key)
session.add(f)
owner_pubs = [k.public_key for k in owner.keys]
owner_privs = [k.private_key for k in owner.keys]
recipients = owner_pubs + [k.public_key for k in f.keys]
with open(query_file, 'rb') as o:
data = o.read()
decrypted = utils.decrypt(data, owner_privs, owner_pubs, passwd)
with tempfile.NamedTemporaryFile() as tmp:
tmp.write(decrypted)
tmp.flush()
tmp.seek(0)
encrypted = utils.encrypt(tmp, recipients)
tmp = tempfile.NamedTemporaryFile(dir=self.storage_dir, delete=False)
tmp.write(encrypted)
os.rename(tmp.name, query_file)
self.request.session.flash(
u'successfully shared file: %s with user %s' % (self.filename, share_user)
)
return HTTPFound(location=self.request.route_url('view_files'))
with utils.db_session(self.dbmaker) as session:
sharable_users = session.query(User).filter(User.sharable==True)
sharable_users = sharable_users.filter(User.username!=self.username).all()
sharable_users = [u.username for u in sharable_users]
return dict(
username=self.username,
filename=self.filename,
sharable_users=sharable_users
)
def upload_file(self):
self.require_key()
with utils.db_session(self.dbmaker) as session:
user = session.query(User).filter(User.username==self.username).first()
if 'uploaded_file' in self.request.POST and form.validate():
f = form.data['uploaded_file']
name = f['filename']
size = f['size']
self.request.session.flash(u'successfully uploaded file %s.' % (name, ))
pubs = []
for key in user.keys:
pubs.append(key.public_key)
encrypted = utils.encrypt(f['file'], pubs)
name = utils.store_file(encrypted, name, user.username, self.storage_dir)
fileobj = File(name, size, user.id)
fileobj.owner = user
for key in user.keys:
fileobj.keys.append(key)
user.files.append(fileobj)
session.add(user)
return HTTPFound(location=self.request.route_url('view_files'))
def test_decrypt_creates_valid_msg(self):
pub, priv = utils.keygen(self.name, self.email, self.passphrase)
encrypted = utils.encrypt(self.file, pub)
decrypted = utils.decrypt(encrypted, priv, pub, self.passphrase)
self.assertEquals(decrypted, self.message)
def test_encrypt_creates_valid_msg(self):
pub, priv = utils.keygen(self.name, self.email, self.passphrase)
encrypted = utils.encrypt(self.file, pub)
self.assertTrue(encrypted.startswith('-----BEGIN PGP MESSAGE-----'))
self.assertTrue(encrypted.endswith('-----END PGP MESSAGE-----\n'))
