bpo-31702: Allow to specify rounds for SHA-2 hashing in crypt.mksalt().

Doc/library/crypt.rst

@@ -116,7 +116,7 @@ The :mod:`crypt` module defines the following functions:
       Accept ``crypt.METHOD_*`` values in addition to strings for *salt*.
 
 
-.. function:: mksalt(method=None, *, log_rounds=12)
+.. function:: mksalt(method=None, *, rounds=None)
 
    Return a randomly generated salt of the specified method.  If no
    *method* is given, the strongest method available as returned by
@@ -125,14 +125,18 @@ The :mod:`crypt` module defines the following functions:
    The return value is a string suitable for passing as the *salt* argument
    to :func:`crypt`.
 
-   *log_rounds* specifies the binary logarithm of the number of rounds
-   for ``crypt.METHOD_BLOWFISH``, and is ignored otherwise.  ``8`` specifies
-   ``256`` rounds.
+   *rounds* specifies the number of rounds for ``METHOD_SHA256``,
+   ``METHOD_SHA512`` and ``METHOD_BLOWFISH``, and is ignored otherwise.
+   For ``METHOD_SHA256`` and ``METHOD_SHA512`` it must be an integer between
+   ``1000`` and ``999999999``.  For ``METHOD_BLOWFISH`` it must be a power of
+   two between ``16`` and ``2147483648`` (2\ :sup:`32`), the default is
+   ``4096``.  If it isn't a power of two, it will be rounded up to the next
+   power of two.
 
    .. versionadded:: 3.3
 
    .. versionchanged:: 3.7
-      Added the *log_rounds* parameter.
+      Added the *rounds* parameter.
 
 
 Examples

Doc/whatsnew/3.7.rst

@@ -235,6 +235,9 @@ crypt
 Added support for the Blowfish method.
 (Contributed by Serhiy Storchaka in :issue:`31664`.)
 
+The :func:`~crypt.mksalt` function now allows to specify the number of rounds
+for hashing.  (Contributed by Serhiy Storchaka in :issue:`31702`.)
+
 dis
 ---
 

Lib/crypt.py

@@ -19,7 +19,7 @@ def __repr__(self):
         return '<crypt.METHOD_{}>'.format(self.name)
 
 
-def mksalt(method=None, *, log_rounds=12):
+def mksalt(method=None, *, rounds=None):
     """Generate a salt for the specified method.
 
     If not specified, the strongest available method will be used.
@@ -30,7 +30,13 @@ def mksalt(method=None, *, log_rounds=12):
     if not method.ident:
         s = ''
     elif method.ident[0] == '2':
+        if rounds is None:
+            log_rounds = 12
+        else:
+            log_rounds = (rounds-1).bit_length()
         s = f'${method.ident}${log_rounds:02d}$'
+    elif method.ident in ('5', '6') and rounds is not None:
+        s = f'${method.ident}$rounds={rounds}$'
     else:
         s = f'${method.ident}$'
     s += ''.join(_sr.choice(_saltchars) for char in range(method.salt_chars))
@@ -55,10 +61,10 @@ def crypt(word, salt=None):
 #  available salting/crypto methods
 methods = []
 
-def _add_method(name, *args):
+def _add_method(name, *args, rounds=None):
     method = _Method(name, *args)
     globals()['METHOD_' + name] = method
-    salt = mksalt(method, log_rounds=4)
+    salt = mksalt(method, rounds=rounds)
     result = crypt('', salt)
     if result and len(result) == method.total_size:
         methods.append(method)
@@ -74,7 +80,7 @@ def _add_method(name, *args):
 # 'y' is the same as 'b', for compatibility
 # with openwall crypt_blowfish.
 for _v in 'b', 'y', 'a', '':
-    if _add_method('BLOWFISH', '2' + _v, 22, 59 + len(_v)):
+    if _add_method('BLOWFISH', '2' + _v, 22, 59 + len(_v), rounds=16):
         break
 
 _add_method('MD5', '1', 8, 34)

Lib/test/test_crypt.py

@@ -39,12 +39,26 @@ def test_methods(self):
         else:
             self.assertEqual(crypt.methods[-1], crypt.METHOD_CRYPT)
 
+    @unittest.skipUnless(crypt.METHOD_SHA256 in crypt.methods or
+                         crypt.METHOD_SHA512 in crypt.methods,
+                        'requires support of SHA-2')
+    def test_sha2_rounds(self):
+        for method in (crypt.METHOD_SHA256, crypt.METHOD_SHA512):
+            for rounds in 1000, 10000, 100000:
+                salt = crypt.mksalt(method, rounds=rounds)
+                self.assertIn('$rounds=%d$' % rounds, salt)
+                self.assertEqual(len(salt) - method.salt_chars,
+                                 11 + len(str(rounds)))
+                cr = crypt.crypt('mypassword', salt)
+                self.assertTrue(cr)
+                cr2 = crypt.crypt('mypassword', cr)
+                self.assertEqual(cr2, cr)
+
     @unittest.skipUnless(crypt.METHOD_BLOWFISH in crypt.methods,
                         'requires support of Blowfish')
-    def test_log_rounds(self):
-        self.assertEqual(len(crypt._saltchars), 64)
+    def test_blowfish_rounds(self):
         for log_rounds in range(4, 11):
-            salt = crypt.mksalt(crypt.METHOD_BLOWFISH, log_rounds=log_rounds)
+            salt = crypt.mksalt(crypt.METHOD_BLOWFISH, rounds=1<<log_rounds)
             self.assertIn('$%02d$' % log_rounds, salt)
             self.assertIn(len(salt) - crypt.METHOD_BLOWFISH.salt_chars, {6, 7})
             cr = crypt.crypt('mypassword', salt)
@@ -54,9 +68,9 @@ def test_log_rounds(self):
 
     @unittest.skipUnless(crypt.METHOD_BLOWFISH in crypt.methods,
                         'requires support of Blowfish')
-    def test_invalid_log_rounds(self):
-        for log_rounds in (1, -1, 999):
-            salt = crypt.mksalt(crypt.METHOD_BLOWFISH, log_rounds=log_rounds)
+    def test_invalid_rounds(self):
+        for log_rounds in (0, 1, 1<<999):
+            salt = crypt.mksalt(crypt.METHOD_BLOWFISH, rounds=rounds)
             self.assertIsNone(crypt.crypt('mypassword', salt))
 
 

Misc/NEWS.d/next/Library/2017-10-24-21-10-44.bpo-31702.SfwJDI.rst

@@ -0,0 +1,2 @@
+crypt.mksalt() now allows to specify the number of rounds for SHA-256 and
+SHA-512 hashing.