class EncryptedPasswordsEntry(TestCase):
def setUp(self):
self.engine = CryptoEngine(master_key='mykeyisawesome!')
self.texts = CryptoEngineTest._generate_texts(100)
def test_save_entry_with_encrypted_key(self):
c = Category(title='Internet')
c.save()
for i, password in enumerate(self.texts):
password_after_encryption = self.engine.encrypt(password)
title = 'My Twitter Account: ' + str(i)
e = Entry(title=title, username='******',
url='twitter.com', password=password_after_encryption,
comment='no comment')
e.category = c
e.save()
# Fetches the saved entry
f = Entry.objects.filter(title=title)[0]
password_decrypted = self.engine.decrypt(f.password)
self.assertEquals(password_after_encryption, f.password)
self.assertEquals(password_decrypted, password)
f.delete()
class EncryptedPasswordsEntry(TestCase):
def setUp(self):
self.engine = CryptoEngine(master_key='mykeyisawesome!')
self.texts = CryptoEngineTest._generate_texts(100)
def test_save_entry_with_encrypted_key(self):
c = Category(title='Internet')
c.save()
for i, password in enumerate(self.texts):
password_after_encryption = self.engine.encrypt(password)
title = 'My Twitter Account: ' + str(i)
e = Entry(title=title,
username='******',
url='twitter.com',
password=password_after_encryption,
comment='no comment')
e.category = c
e.save()
# Fetches the saved entry
f = Entry.objects.filter(title=title)[0]
password_decrypted = self.engine.decrypt(f.password)
self.assertEquals(password_after_encryption, f.password)
self.assertEquals(password_decrypted, password)
f.delete()
def post(self, request, *args, **kwargs):
if request.user.is_superuser:
engine = CryptoEngine(master_key=request.user.password)
form = EntryForm(request.POST)
if form.is_valid():
entry = form.save(commit=False)
entry.password = engine.encrypt(form.cleaned_data['password'])
entry.save()
messages.add_message(request, messages.INFO, u'New entry added: {}'.format(entry.title))
return redirect('home')
else:
form = EntryForm()
return render(request, self.template_name, locals())
def post_entry_add(request):
engine = CryptoEngine(master_key=request.user.password)
e = None
attributes = set(['title', 'password', 'category'])
if attributes <= set(request.POST.keys()):
e = Entry(title=request.POST['title'],
password=request.POST['password'])
for k, v in request.POST.items():
if k == 'username':
e.username = v
elif k == 'url':
e.url = v
elif k == 'comment':
e.comment = v
elif k == 'expires':
# date formated: m/d/Y
e.expires = datetime.datetime.strptime(v, "%m/%d/%Y").date()
elif k == 'category':
c = Category.objects.filter(id=int(v))
if len(c) == 0:
return HttpResponse(0)
else:
e.category_id = int(v)
try:
e.save()
return HttpResponse(1)
except:
return HttpResponse(0)
else:
return HttpResponse(0)
def post(self, request, *args, **kwargs):
if request.user.is_superuser:
engine = CryptoEngine(master_key=request.user.password)
form = EntryForm(request.POST)
if form.is_valid():
entry = form.save(commit=False)
entry.password = engine.encrypt(form.cleaned_data['password'])
entry.save()
messages.add_message(
request, messages.INFO,
u'New entry added: {}'.format(entry.title))
return redirect('home')
else:
form = EntryForm()
return render(request, self.template_name, locals())
class CryptoEngineTest(TestCase):
def setUp(self):
self.engine = CryptoEngine(master_key='mykeyisawesome!')
self.block_length = 32
self.texts = CryptoEngineTest._generate_texts(100)
def test_padding(self):
for t in self.texts:
padded_text = self.engine._pad(t)
self.assertEquals(len(padded_text) % self.block_length, 0)
def test_depadding(self):
for p, t in zip([
t + ''.join([
self.engine.PADDING for i in xrange(random.randint(1, 10))
]) for t in self.texts
], self.texts):
self.assertEquals(t, self.engine._depad(p))
def test_decryption(self):
for t in self.texts:
cipher_text = self.engine.encrypt(t)
self.assertEquals(self.engine.decrypt(cipher_text), t)
@classmethod
def _generate_texts(cls, limit):
allowed_char = map(chr, range(97, 123))
allowed_char += map(chr, range(65, 91))
allowed_char += [str(i) for i in xrange(0, 10)]
allowed_char += map(chr, range(33, 47))
min_length = 1
max_length = len(allowed_char) - 1
texts = []
for i in xrange(limit):
length = random.randint(min_length, max_length)
random.shuffle(allowed_char)
texts += [''.join(allowed_char[:length])]
return texts
class CryptoEngineTest(TestCase):
def setUp(self):
self.engine = CryptoEngine(master_key='mykeyisawesome!')
self.block_length = 32
self.texts = CryptoEngineTest._generate_texts(100)
def test_padding(self):
for t in self.texts:
padded_text = self.engine._pad(t)
self.assertEquals(len(padded_text) % self.block_length, 0)
def test_depadding(self):
for p, t in zip([t + ''.join([self.engine.PADDING
for i in xrange(random.randint(1, 10))])
for t in self.texts], self.texts):
self.assertEquals(t, self.engine._depad(p))
def test_decryption(self):
for t in self.texts:
cipher_text = self.engine.encrypt(t)
self.assertEquals(self.engine.decrypt(cipher_text), t)
@classmethod
def _generate_texts(cls, limit):
allowed_char = map(chr, range(97, 123))
allowed_char += map(chr, range(65, 91))
allowed_char += [str(i) for i in xrange(0, 10)]
allowed_char += map(chr, range(33, 47))
min_length = 1
max_length = len(allowed_char) - 1
texts = []
for i in xrange(limit):
length = random.randint(min_length, max_length)
random.shuffle(allowed_char)
texts += [''.join(allowed_char[:length])]
return texts
def get_search(request):
engine = CryptoEngine(master_key=request.user.password)
entries = None
if 'title' in request.GET:
search = str(request.GET['title'])
entries = Entry.objects.filter(title__contains=search)
elif 'category' in request.GET:
search = str(request.GET['category'])
categories = Category.objects.filter(title__contains=search)
entries = [e for c in categories for e in c.entry_set.all()]
else:
entries = Entry.objects.all()
# Decrypts the passwords
for e in entries:
e.password = engine.decrypt(e.password)
response_data = [e.dict() for e in entries]
return HttpResponse(json.dumps(response_data), content_type="application/json")
def get_search(request):
engine = CryptoEngine(master_key=request.user.password)
entries = None
if 'title' in request.GET:
search = str(request.GET['title'])
entries = Entry.objects.filter(title__contains=search)
elif 'category' in request.GET:
search = str(request.GET['category'])
categories = Category.objects.filter(title__contains=search)
entries = [e for c in categories for e in c.entry_set.all()]
else:
entries = Entry.objects.all()
# Decrypts the passwords
for e in entries:
e.password = engine.decrypt(e.password)
response_data = [e.dict() for e in entries]
return HttpResponse(json.dumps(response_data),
content_type="application/json")
def setUp(self):
self.engine = CryptoEngine(master_key='mykeyisawesome!')
self.block_length = 32
self.texts = CryptoEngineTest._generate_texts(100)
def decrypt(text, master_key):
engine = CryptoEngine(master_key=master_key)
return engine.decrypt(text)
def setUp(self):
self.engine = CryptoEngine(master_key='mykeyisawesome!')
self.block_length = 32
self.texts = CryptoEngineTest._generate_texts(100)
