Ticket #21105: 0001-PBKDF2PrehashPasswordHasher.patch

django/conf/global_settings.py

@@ -516 +516 @@
 # password using different algorithms will be converted automatically
 # upon login
 PASSWORD_HASHERS = (
+    'django.contrib.auth.hashers.PBKDF2PrehashPasswordHasher',
     'django.contrib.auth.hashers.PBKDF2PasswordHasher',
     'django.contrib.auth.hashers.PBKDF2SHA1PasswordHasher',
     'django.contrib.auth.hashers.BCryptSHA256PasswordHasher',

django/contrib/auth/hashers.py

@@ -267 +267 @@
         ])
 
 
+class PBKDF2PrehashPasswordHasher(BasePasswordHasher):
+    """
+    Secure password hashing using the PBKDF2 algorithm (recommended)
+
+    Configured to use PBKDF2 + HMAC + SHA256 with 10000 iterations.
+    The result is a 64 byte binary string.  Iterations may be changed
+    safely but you must rename the algorithm if you change SHA256.
+    
+    Pre-hashes the password with SHA256 before hashing in order to ensure that
+    computation time doesn't depend on password length.
+    """
+    algorithm = "pbkdf2_prehash_sha256"
+    iterations = 10000
+    digest = hashlib.sha256
+    prehash = True
+
+    @password_max_length(MAXIMUM_PASSWORD_LENGTH)
+    def encode(self, password, salt, iterations=None):
+        assert password is not None
+        assert salt and '$' not in salt
+        if not iterations:
+            iterations = self.iterations
+        prehashed_password = binascii.hexlify(
+            self.digest(force_bytes(password)).digest()
+        )
+        hash = pbkdf2(prehashed_password, salt, iterations, digest=self.digest)
+        hash = base64.b64encode(hash).decode('ascii').strip()
+        return "%s$%d$%s$%s$%s" % (self.algorithm, iterations, salt,
+                                   'prehash', hash)
+
+    @password_max_length(MAXIMUM_PASSWORD_LENGTH)
+    def verify(self, password, encoded):
+        algorithm, iterations, salt, prehash, hash = encoded.split('$', 4)
+        assert algorithm == self.algorithm
+        assert prehash == 'prehash'
+        encoded_2 = self.encode(password, salt, int(iterations))
+        return constant_time_compare(encoded, encoded_2)
+
+    def safe_summary(self, encoded):
+        algorithm, iterations, salt, prehash, hash = encoded.split('$', 4)
+        assert algorithm == self.algorithm
+        assert prehash == True
+        return SortedDict([
+            (_('algorithm'), algorithm),
+            (_('iterations'), iterations),
+            (_('salt'), mask_hash(salt)),
+            (_('prehash'), 'prehash'),
+            (_('hash'), mask_hash(hash)),
+        ])
+
+
 class PBKDF2SHA1PasswordHasher(PBKDF2PasswordHasher):
     """
     Alternate PBKDF2 hasher which uses SHA1, the default PRF

django/contrib/auth/tests/test_hashers.py

@@ -4 +4 @@
 from django.conf.global_settings import PASSWORD_HASHERS as default_hashers
 from django.contrib.auth.hashers import (
     is_password_usable, BasePasswordHasher, check_password, make_password,
-    PBKDF2PasswordHasher, load_hashers, PBKDF2SHA1PasswordHasher, get_hasher,
-    identify_hasher, UNUSABLE_PASSWORD_PREFIX, UNUSABLE_PASSWORD_SUFFIX_LENGTH,
+    PBKDF2PasswordHasher, PBKDF2PrehashPasswordHasher, load_hashers,
+    PBKDF2SHA1PasswordHasher, get_hasher, identify_hasher,
+    UNUSABLE_PASSWORD_PREFIX, UNUSABLE_PASSWORD_SUFFIX_LENGTH,
     MAXIMUM_PASSWORD_LENGTH, password_max_length
 )
 from django.utils import six
@@ -31 +32 @@
 
     def test_simple(self):
         encoded = make_password('lètmein')
-        self.assertTrue(encoded.startswith('pbkdf2_sha256$'))
+        self.assertTrue(encoded.startswith('pbkdf2_prehash_sha256$'))
         self.assertTrue(is_password_usable(encoded))
         self.assertTrue(check_password('lètmein', encoded))
         self.assertFalse(check_password('lètmeinz', encoded))
         # Blank passwords
         blank_encoded = make_password('')
-        self.assertTrue(blank_encoded.startswith('pbkdf2_sha256$'))
+        self.assertTrue(blank_encoded.startswith('pbkdf2_prehash_sha256$'))
         self.assertTrue(is_password_usable(blank_encoded))
         self.assertTrue(check_password('', blank_encoded))
         self.assertFalse(check_password(' ', blank_encoded))
@@ -288 +289 @@
             'pbkdf2_sha256$10000$seasalt$CWWFdHOWwPnki7HvkcqN9iA2T3KLW1cf2uZ5kvArtVY=')
         self.assertTrue(hasher.verify('lètmein', encoded))
 
+    def test_low_level_pkbdf2_prehash(self):
+        hasher = PBKDF2PrehashPasswordHasher()
+        encoded = hasher.encode('lètmein', 'seasalt')
+        self.assertEqual(encoded,
+            'pbkdf2_prehash_sha256$10000$seasalt$prehash$5EsXdehiy03QeCdmMU7KfjYz30oUqDNX0uNkHIWTXqg=')
+        self.assertTrue(hasher.verify('lètmein', encoded))
+
     def test_low_level_pbkdf2_sha1(self):
         hasher = PBKDF2SHA1PasswordHasher()
         encoded = hasher.encode('lètmein', 'seasalt')
@@ -296 +304 @@
         self.assertTrue(hasher.verify('lètmein', encoded))
 
     def test_upgrade(self):
-        self.assertEqual('pbkdf2_sha256', get_hasher('default').algorithm)
+        self.assertEqual('pbkdf2_prehash_sha256', get_hasher('default').algorithm)
         for algo in ('sha1', 'md5'):
             encoded = make_password('lètmein', hasher=algo)
             state = {'upgraded': False}
@@ -314 +322 @@
         self.assertFalse(state['upgraded'])
 
     def test_no_upgrade_on_incorrect_pass(self):
-        self.assertEqual('pbkdf2_sha256', get_hasher('default').algorithm)
+        self.assertEqual('pbkdf2_prehash_sha256', get_hasher('default').algorithm)
         for algo in ('sha1', 'md5'):
             encoded = make_password('lètmein', hasher=algo)
             state = {'upgraded': False}