Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Browse files

Fixed #19509 -- Fixed crypt/bcrypt non-ascii password encoding

Also systematically added non-ascii passwords in hashers test suite.
Thanks Vaal for the report.
  • Loading branch information...
commit 0dc3fc954f53d5b03b864e63b309acfdbb40dbf9 1 parent 1e4a27d
@claudep claudep authored
View
12 django/contrib/auth/hashers.py
@@ -8,7 +8,7 @@
from django.test.signals import setting_changed
from django.utils import importlib
from django.utils.datastructures import SortedDict
-from django.utils.encoding import force_bytes
+from django.utils.encoding import force_bytes, force_str
from django.core.exceptions import ImproperlyConfigured
from django.utils.crypto import (
pbkdf2, constant_time_compare, get_random_string)
@@ -275,14 +275,16 @@ def salt(self):
def encode(self, password, salt):
bcrypt = self._load_library()
- data = bcrypt.hashpw(password, salt)
+ # Need to reevaluate the force_bytes call once bcrypt is supported on
+ # Python 3
+ data = bcrypt.hashpw(force_bytes(password), salt)
return "%s$%s" % (self.algorithm, data)
def verify(self, password, encoded):
algorithm, data = encoded.split('$', 1)
assert algorithm == self.algorithm
bcrypt = self._load_library()
- return constant_time_compare(data, bcrypt.hashpw(password, data))
+ return constant_time_compare(data, bcrypt.hashpw(force_bytes(password), data))
def safe_summary(self, encoded):
algorithm, empty, algostr, work_factor, data = encoded.split('$', 4)
@@ -395,7 +397,7 @@ def salt(self):
def encode(self, password, salt):
crypt = self._load_library()
assert len(salt) == 2
- data = crypt.crypt(password, salt)
+ data = crypt.crypt(force_str(password), salt)
# we don't need to store the salt, but Django used to do this
return "%s$%s$%s" % (self.algorithm, '', data)
@@ -403,7 +405,7 @@ def verify(self, password, encoded):
crypt = self._load_library()
algorithm, salt, data = encoded.split('$', 2)
assert algorithm == self.algorithm
- return constant_time_compare(data, crypt.crypt(password, data))
+ return constant_time_compare(data, crypt.crypt(force_str(password), data))
def safe_summary(self, encoded):
algorithm, salt, data = encoded.split('$', 2)
View
89 django/contrib/auth/tests/hashers.py
@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from django.conf.global_settings import PASSWORD_HASHERS as default_hashers
@@ -25,63 +26,63 @@ def setUp(self):
load_hashers(password_hashers=default_hashers)
def test_simple(self):
- encoded = make_password('letmein')
+ encoded = make_password('lètmein')
self.assertTrue(encoded.startswith('pbkdf2_sha256$'))
self.assertTrue(is_password_usable(encoded))
- self.assertTrue(check_password('letmein', encoded))
- self.assertFalse(check_password('letmeinz', encoded))
+ self.assertTrue(check_password('lètmein', encoded))
+ self.assertFalse(check_password('lètmeinz', encoded))
def test_pkbdf2(self):
- encoded = make_password('letmein', 'seasalt', 'pbkdf2_sha256')
- self.assertEqual(encoded,
-'pbkdf2_sha256$10000$seasalt$FQCNpiZpTb0zub+HBsH6TOwyRxJ19FwvjbweatNmK/Y=')
+ encoded = make_password('lètmein', 'seasalt', 'pbkdf2_sha256')
+ self.assertEqual(encoded,
+ 'pbkdf2_sha256$10000$seasalt$CWWFdHOWwPnki7HvkcqN9iA2T3KLW1cf2uZ5kvArtVY=')
self.assertTrue(is_password_usable(encoded))
- self.assertTrue(check_password('letmein', encoded))
- self.assertFalse(check_password('letmeinz', encoded))
+ self.assertTrue(check_password('lètmein', encoded))
+ self.assertFalse(check_password('lètmeinz', encoded))
self.assertEqual(identify_hasher(encoded).algorithm, "pbkdf2_sha256")
def test_sha1(self):
- encoded = make_password('letmein', 'seasalt', 'sha1')
- self.assertEqual(encoded,
-'sha1$seasalt$fec3530984afba6bade3347b7140d1a7da7da8c7')
+ encoded = make_password('lètmein', 'seasalt', 'sha1')
+ self.assertEqual(encoded,
+ 'sha1$seasalt$cff36ea83f5706ce9aa7454e63e431fc726b2dc8')
self.assertTrue(is_password_usable(encoded))
- self.assertTrue(check_password('letmein', encoded))
- self.assertFalse(check_password('letmeinz', encoded))
+ self.assertTrue(check_password('lètmein', encoded))
+ self.assertFalse(check_password('lètmeinz', encoded))
self.assertEqual(identify_hasher(encoded).algorithm, "sha1")
def test_md5(self):
- encoded = make_password('letmein', 'seasalt', 'md5')
+ encoded = make_password('lètmein', 'seasalt', 'md5')
self.assertEqual(encoded,
- 'md5$seasalt$f5531bef9f3687d0ccf0f617f0e25573')
+ 'md5$seasalt$3f86d0d3d465b7b458c231bf3555c0e3')
self.assertTrue(is_password_usable(encoded))
- self.assertTrue(check_password('letmein', encoded))
- self.assertFalse(check_password('letmeinz', encoded))
+ self.assertTrue(check_password('lètmein', encoded))
+ self.assertFalse(check_password('lètmeinz', encoded))
self.assertEqual(identify_hasher(encoded).algorithm, "md5")
def test_unsalted_md5(self):
- encoded = make_password('letmein', 'seasalt', 'unsalted_md5')
- self.assertEqual(encoded, '0d107d09f5bbe40cade3de5c71e9e9b7')
+ encoded = make_password('lètmein', 'seasalt', 'unsalted_md5')
+ self.assertEqual(encoded, '88a434c88cca4e900f7874cd98123f43')
self.assertTrue(is_password_usable(encoded))
- self.assertTrue(check_password('letmein', encoded))
- self.assertFalse(check_password('letmeinz', encoded))
+ self.assertTrue(check_password('lètmein', encoded))
+ self.assertFalse(check_password('lètmeinz', encoded))
self.assertEqual(identify_hasher(encoded).algorithm, "unsalted_md5")
@skipUnless(crypt, "no crypt module to generate password.")
def test_crypt(self):
- encoded = make_password('letmein', 'ab', 'crypt')
- self.assertEqual(encoded, 'crypt$$abN/qM.L/H8EQ')
+ encoded = make_password('lètmei', 'ab', 'crypt')
+ self.assertEqual(encoded, 'crypt$$ab1Hv2Lg7ltQo')
self.assertTrue(is_password_usable(encoded))
- self.assertTrue(check_password('letmein', encoded))
- self.assertFalse(check_password('letmeinz', encoded))
+ self.assertTrue(check_password('lètmei', encoded))
+ self.assertFalse(check_password('lètmeiz', encoded))
self.assertEqual(identify_hasher(encoded).algorithm, "crypt")
@skipUnless(bcrypt, "py-bcrypt not installed")
def test_bcrypt(self):
- encoded = make_password('letmein', hasher='bcrypt')
+ encoded = make_password('lètmein', hasher='bcrypt')
self.assertTrue(is_password_usable(encoded))
self.assertTrue(encoded.startswith('bcrypt$'))
- self.assertTrue(check_password('letmein', encoded))
- self.assertFalse(check_password('letmeinz', encoded))
+ self.assertTrue(check_password('lètmein', encoded))
+ self.assertFalse(check_password('lètmeinz', encoded))
self.assertEqual(identify_hasher(encoded).algorithm, "bcrypt")
def test_unusable(self):
@@ -90,46 +91,46 @@ def test_unusable(self):
self.assertFalse(check_password(None, encoded))
self.assertFalse(check_password(UNUSABLE_PASSWORD, encoded))
self.assertFalse(check_password('', encoded))
- self.assertFalse(check_password('letmein', encoded))
- self.assertFalse(check_password('letmeinz', encoded))
+ self.assertFalse(check_password('lètmein', encoded))
+ self.assertFalse(check_password('lètmeinz', encoded))
self.assertRaises(ValueError, identify_hasher, encoded)
def test_bad_algorithm(self):
def doit():
- make_password('letmein', hasher='lolcat')
+ make_password('lètmein', hasher='lolcat')
self.assertRaises(ValueError, doit)
self.assertRaises(ValueError, identify_hasher, "lolcat$salt$hash")
def test_bad_encoded(self):
- self.assertFalse(is_password_usable('letmein_badencoded'))
+ self.assertFalse(is_password_usable('lètmein_badencoded'))
self.assertFalse(is_password_usable(''))
def test_low_level_pkbdf2(self):
hasher = PBKDF2PasswordHasher()
- encoded = hasher.encode('letmein', 'seasalt')
- self.assertEqual(encoded,
-'pbkdf2_sha256$10000$seasalt$FQCNpiZpTb0zub+HBsH6TOwyRxJ19FwvjbweatNmK/Y=')
- self.assertTrue(hasher.verify('letmein', encoded))
+ encoded = hasher.encode('lètmein', 'seasalt')
+ self.assertEqual(encoded,
+ 'pbkdf2_sha256$10000$seasalt$CWWFdHOWwPnki7HvkcqN9iA2T3KLW1cf2uZ5kvArtVY=')
+ self.assertTrue(hasher.verify('lètmein', encoded))
def test_low_level_pbkdf2_sha1(self):
hasher = PBKDF2SHA1PasswordHasher()
- encoded = hasher.encode('letmein', 'seasalt')
- self.assertEqual(encoded,
-'pbkdf2_sha1$10000$seasalt$91JiNKgwADC8j2j86Ije/cc4vfQ=')
- self.assertTrue(hasher.verify('letmein', encoded))
+ encoded = hasher.encode('lètmein', 'seasalt')
+ self.assertEqual(encoded,
+ 'pbkdf2_sha1$10000$seasalt$oAfF6vgs95ncksAhGXOWf4Okq7o=')
+ self.assertTrue(hasher.verify('lètmein', encoded))
def test_upgrade(self):
self.assertEqual('pbkdf2_sha256', get_hasher('default').algorithm)
for algo in ('sha1', 'md5'):
- encoded = make_password('letmein', hasher=algo)
+ encoded = make_password('lètmein', hasher=algo)
state = {'upgraded': False}
def setter(password):
state['upgraded'] = True
- self.assertTrue(check_password('letmein', encoded, setter))
+ self.assertTrue(check_password('lètmein', encoded, setter))
self.assertTrue(state['upgraded'])
def test_no_upgrade(self):
- encoded = make_password('letmein')
+ encoded = make_password('lètmein')
state = {'upgraded': False}
def setter():
state['upgraded'] = True
@@ -139,7 +140,7 @@ def setter():
def test_no_upgrade_on_incorrect_pass(self):
self.assertEqual('pbkdf2_sha256', get_hasher('default').algorithm)
for algo in ('sha1', 'md5'):
- encoded = make_password('letmein', hasher=algo)
+ encoded = make_password('lètmein', hasher=algo)
state = {'upgraded': False}
def setter():
state['upgraded'] = True
Please sign in to comment.
Something went wrong with that request. Please try again.