Added fallback signers and switch back to sha1

3 files changed, 59 insertions, 9 deletions

diff --git a/src/itsdangerous/serializer.py b/src/itsdangerous/serializer.py
index 1e764d5..6d9403f 100644
--- a/src/itsdangerous/serializer.py
+++ b/src/itsdangerous/serializer.py
@@ -32,9 +32,29 @@ class Serializer(object):
 
         s = Serializer(signer_kwargs={'key_derivation': 'hmac'})
 
+    Additionally as of 1.1 fallback signers can be defined by providing
+    a list as `fallback_signers`.  These are used for deserialization as a
+    fallback.  Each item can be one of the following:
+    a signer class (which is instanciated with `signer_kwargs`, salt and
+    secret key), a tuple `(signer_class, signer_kwargs)` or just `signer_kwargs`.
+    If kwargs are provided they need to be a dict.
+
+    For instance this is a serializer that supports deserialization that
+    supports both SHA1 and SHA512:
+
+    .. code-block:: python3
+
+        s = Serializer(
+            signer_kwargs={'digest_method': hashlib.sha512},
+            fallback_signers=[{'digest_method': hashlib.sha1}]
+        )
+
     .. versionchanged:: 0.14:
         The ``signer`` and ``signer_kwargs`` parameters were added to
         the constructor.
+
+    .. versionchanged:: 1.1:
+        Added support for `fallback_signers`.
     """
 
     #: If a serializer module or class is not passed to the constructor
@@ -55,6 +75,7 @@ class Serializer(object):
         serializer_kwargs=None,
         signer=None,
         signer_kwargs=None,
+        fallback_signers=None,
     ):
         self.secret_key = want_bytes(secret_key)
         self.salt = want_bytes(salt)
@@ -66,6 +87,7 @@ class Serializer(object):
             signer = self.default_signer
         self.signer = signer
         self.signer_kwargs = signer_kwargs or {}
+        self.fallback_signers = fallback_signers or ()
         self.serializer_kwargs = serializer_kwargs or {}
 
     def load_payload(self, payload, serializer=None):
@@ -106,6 +128,21 @@ class Serializer(object):
             salt = self.salt
         return self.signer(self.secret_key, salt=salt, **self.signer_kwargs)
 
+    def iter_unsigners(self, salt=None):
+        """Iterates over all signers for unsigning."""
+        if salt is None:
+            salt = self.salt
+        yield self.make_signer(salt)
+        for fallback in self.fallback_signers:
+            if type(fallback) is dict:
+                kwargs = fallback
+                fallback = self.signer
+            elif type(fallback) is tuple:
+                fallback, kwargs = fallback
+            else:
+                kwargs = self.signer_kwargs
+            yield fallback(self.secret_key, salt=salt, **kwargs)
+
     def dumps(self, obj, salt=None):
         """Returns a signed string serialized with the internal
         serializer. The return value can be either a byte or unicode
@@ -128,7 +165,13 @@ class Serializer(object):
         signature validation fails.
         """
         s = want_bytes(s)
-        return self.load_payload(self.make_signer(salt).unsign(s))
+        last_exception = None
+        for signer in self.iter_unsigners(salt):
+            try:
+                return self.load_payload(signer.unsign(s))
+            except BadSignature as err:
+                last_exception = err
+        raise last_exception
 
     def load(self, f, salt=None):
         """Like :meth:`loads` but loads from a file."""
diff --git a/src/itsdangerous/signer.py b/src/itsdangerous/signer.py
index 5b3d6c3..84932e5 100644
--- a/src/itsdangerous/signer.py
+++ b/src/itsdangerous/signer.py
@@ -40,10 +40,7 @@ class HMACAlgorithm(SigningAlgorithm):
     #: The digest method to use with the MAC algorithm. This defaults to
     #: SHA-512, but can be changed to any other function in the hashlib
     #: module.
-    #:
-    #: .. versionchanged:: 1.0
-    #:     The default was changed from SHA-1 to SHA-512.
-    default_digest_method = staticmethod(hashlib.sha512)
+    default_digest_method = staticmethod(hashlib.sha1)
 
     def __init__(self, digest_method=None):
         if digest_method is None:
@@ -80,11 +77,8 @@ class Signer(object):
     #: SHA-512 but can be changed to any other function in the hashlib
     #: module.
     #:
-    #: .. versionchanged:: 1.0
-    #:     The default was changed from SHA-1 to SHA-512.
-    #:
     #: .. versionadded:: 0.14
-    default_digest_method = staticmethod(hashlib.sha512)
+    default_digest_method = staticmethod(hashlib.sha1)
 
     #: Controls how the key is derived. The default is Django-style
     #: concatenation. Possible values are ``concat``, ``django-concat``
diff --git a/tests/test_itsdangerous/test_serializer.py b/tests/test_itsdangerous/test_serializer.py
index 465d507..df2fa92 100644
--- a/tests/test_itsdangerous/test_serializer.py
+++ b/tests/test_itsdangerous/test_serializer.py
@@ -1,3 +1,4 @@
+import hashlib
 import pickle
 from functools import partial
 from io import BytesIO
@@ -131,3 +132,15 @@ class TestSerializer(object):
             return
 
         assert serializer.loads(serializer.dumps({(): 1})) == {}
+
+    def test_fallback_signers(self):
+        serializer = Serializer(
+            secret_key="foo", signer_kwargs={"digest_method": hashlib.sha512}
+        )
+        value = serializer.dumps([1, 2, 3])
+        fallback_serializer = Serializer(
+            secret_key="foo",
+            signer_kwargs={"digest_method": hashlib.sha1},
+            fallback_signers=[{"digest_method": hashlib.sha512}],
+        )
+        assert fallback_serializer.loads(value) == [1, 2, 3]