Debian Codegraph @

tests/signing/tests.py

raw
1 import datetime
2
3 from django.core import signing
4 from django.test import SimpleTestCase, override_settings
5 from django.test.utils import freeze_time
6 from django.utils.crypto import InvalidAlgorithm
7
8
9 class TestSigner(SimpleTestCase):
10 def test_signature(self):
11 "signature() method should generate a signature"
12 signer = signing.Signer(key="predictable-secret")
13 signer2 = signing.Signer(key="predictable-secret2")
14 for s in (
15 b"hello",
16 b"3098247:529:087:",
17 "\u2019".encode(),
18 ):
19 self.assertEqual(
20 signer.signature(s),
21 signing.base64_hmac(
22 signer.salt + "signer",
23 s,
24 "predictable-secret",
25 algorithm=signer.algorithm,
26 ),
27 )
28 self.assertNotEqual(signer.signature(s), signer2.signature(s))
29
30 def test_signature_with_salt(self):
31 signer = signing.Signer(key="predictable-secret", salt="extra-salt")
32 self.assertEqual(
33 signer.signature("hello"),
34 signing.base64_hmac(
35 "extra-salt" + "signer",
36 "hello",
37 "predictable-secret",
38 algorithm=signer.algorithm,
39 ),
40 )
41 self.assertNotEqual(
42 signing.Signer(key="predictable-secret", salt="one").signature("hello"),
43 signing.Signer(key="predictable-secret", salt="two").signature("hello"),
44 )
45
46 def test_custom_algorithm(self):
47 signer = signing.Signer(key="predictable-secret", algorithm="sha512")
48 self.assertEqual(
49 signer.signature("hello"),
50 "Usf3uVQOZ9m6uPfVonKR-EBXjPe7bjMbp3_Fq8MfsptgkkM1ojidN0BxYaT5HAEN1"
51 "VzO9_jVu7R-VkqknHYNvw",
52 )
53
54 def test_invalid_algorithm(self):
55 signer = signing.Signer(key="predictable-secret", algorithm="whatever")
56 msg = "'whatever' is not an algorithm accepted by the hashlib module."
57 with self.assertRaisesMessage(InvalidAlgorithm, msg):
58 signer.sign("hello")
59
60 def test_sign_unsign(self):
61 "sign/unsign should be reversible"
62 signer = signing.Signer(key="predictable-secret")
63 examples = [
64 "q;wjmbk;wkmb",
65 "3098247529087",
66 "3098247:529:087:",
67 "jkw osanteuh ,rcuh nthu aou oauh ,ud du",
68 "\u2019",
69 ]
70 for example in examples:
71 signed = signer.sign(example)
72 self.assertIsInstance(signed, str)
73 self.assertNotEqual(example, signed)
74 self.assertEqual(example, signer.unsign(signed))
75
76 def test_sign_unsign_non_string(self):
77 signer = signing.Signer(key="predictable-secret")
78 values = [
79 123,
80 1.23,
81 True,
82 datetime.date.today(),
83 ]
84 for value in values:
85 with self.subTest(value):
86 signed = signer.sign(value)
87 self.assertIsInstance(signed, str)
88 self.assertNotEqual(signed, value)
89 self.assertEqual(signer.unsign(signed), str(value))
90
91 def test_unsign_detects_tampering(self):
92 "unsign should raise an exception if the value has been tampered with"
93 signer = signing.Signer(key="predictable-secret")
94 value = "Another string"
95 signed_value = signer.sign(value)
96 transforms = (
97 lambda s: s.upper(),
98 lambda s: s + "a",
99 lambda s: "a" + s[1:],
100 lambda s: s.replace(":", ""),
101 )
102 self.assertEqual(value, signer.unsign(signed_value))
103 for transform in transforms:
104 with self.assertRaises(signing.BadSignature):
105 signer.unsign(transform(signed_value))
106
107 def test_sign_unsign_object(self):
108 signer = signing.Signer(key="predictable-secret")
109 tests = [
110 ["a", "list"],
111 "a string \u2019",
112 {"a": "dictionary"},
113 ]
114 for obj in tests:
115 with self.subTest(obj=obj):
116 signed_obj = signer.sign_object(obj)
117 self.assertNotEqual(obj, signed_obj)
118 self.assertEqual(obj, signer.unsign_object(signed_obj))
119 signed_obj = signer.sign_object(obj, compress=True)
120 self.assertNotEqual(obj, signed_obj)
121 self.assertEqual(obj, signer.unsign_object(signed_obj))
122
123 def test_dumps_loads(self):
124 "dumps and loads be reversible for any JSON serializable object"
125 objects = [
126 ["a", "list"],
127 "a string \u2019",
128 {"a": "dictionary"},
129 ]
130 for o in objects:
131 self.assertNotEqual(o, signing.dumps(o))
132 self.assertEqual(o, signing.loads(signing.dumps(o)))
133 self.assertNotEqual(o, signing.dumps(o, compress=True))
134 self.assertEqual(o, signing.loads(signing.dumps(o, compress=True)))
135
136 def test_decode_detects_tampering(self):
137 "loads should raise exception for tampered objects"
138 transforms = (
139 lambda s: s.upper(),
140 lambda s: s + "a",
141 lambda s: "a" + s[1:],
142 lambda s: s.replace(":", ""),
143 )
144 value = {
145 "foo": "bar",
146 "baz": 1,
147 }
148 encoded = signing.dumps(value)
149 self.assertEqual(value, signing.loads(encoded))
150 for transform in transforms:
151 with self.assertRaises(signing.BadSignature):
152 signing.loads(transform(encoded))
153
154 def test_works_with_non_ascii_keys(self):
155 binary_key = b"\xe7" # Set some binary (non-ASCII key)
156
157 s = signing.Signer(key=binary_key)
158 self.assertEqual(
159 "foo:EE4qGC5MEKyQG5msxYA0sBohAxLC0BJf8uRhemh0BGU",
160 s.sign("foo"),
161 )
162
163 def test_valid_sep(self):
164 separators = ["/", "*sep*", ","]
165 for sep in separators:
166 signer = signing.Signer(key="predictable-secret", sep=sep)
167 self.assertEqual(
168 "foo%sjZQoX_FtSO70jX9HLRGg2A_2s4kdDBxz1QoO_OpEQb0" % sep,
169 signer.sign("foo"),
170 )
171
172 def test_invalid_sep(self):
173 """should warn on invalid separator"""
174 msg = (
175 "Unsafe Signer separator: %r (cannot be empty or consist of only A-z0-9-_=)"
176 )
177 separators = ["", "-", "abc"]
178 for sep in separators:
179 with self.assertRaisesMessage(ValueError, msg % sep):
180 signing.Signer(sep=sep)
181
182 def test_verify_with_non_default_key(self):
183 old_signer = signing.Signer(key="secret")
184 new_signer = signing.Signer(
185 key="newsecret", fallback_keys=["othersecret", "secret"]
186 )
187 signed = old_signer.sign("abc")
188 self.assertEqual(new_signer.unsign(signed), "abc")
189
190 def test_sign_unsign_multiple_keys(self):
191 """The default key is a valid verification key."""
192 signer = signing.Signer(key="secret", fallback_keys=["oldsecret"])
193 signed = signer.sign("abc")
194 self.assertEqual(signer.unsign(signed), "abc")
195
196 @override_settings(
197 SECRET_KEY="secret",
198 SECRET_KEY_FALLBACKS=["oldsecret"],
199 )
200 def test_sign_unsign_ignore_secret_key_fallbacks(self):
201 old_signer = signing.Signer(key="oldsecret")
202 signed = old_signer.sign("abc")
203 signer = signing.Signer(fallback_keys=[])
204 with self.assertRaises(signing.BadSignature):
205 signer.unsign(signed)
206
207 @override_settings(
208 SECRET_KEY="secret",
209 SECRET_KEY_FALLBACKS=["oldsecret"],
210 )
211 def test_default_keys_verification(self):
212 old_signer = signing.Signer(key="oldsecret")
213 signed = old_signer.sign("abc")
214 signer = signing.Signer()
215 self.assertEqual(signer.unsign(signed), "abc")
216
217
218 class TestTimestampSigner(SimpleTestCase):
219 def test_timestamp_signer(self):
220 value = "hello"
221 with freeze_time(123456789):
222 signer = signing.TimestampSigner(key="predictable-key")
223 ts = signer.sign(value)
224 self.assertNotEqual(ts, signing.Signer(key="predictable-key").sign(value))
225 self.assertEqual(signer.unsign(ts), value)
226
227 with freeze_time(123456800):
228 self.assertEqual(signer.unsign(ts, max_age=12), value)
229 # max_age parameter can also accept a datetime.timedelta object
230 self.assertEqual(
231 signer.unsign(ts, max_age=datetime.timedelta(seconds=11)), value
232 )
233 with self.assertRaises(signing.SignatureExpired):
234 signer.unsign(ts, max_age=10)
235
236
237 class TestBase62(SimpleTestCase):
238 def test_base62(self):
239 tests = [-(10**10), 10**10, 1620378259, *range(-100, 100)]
240 for i in tests:
241 self.assertEqual(i, signing.b62_decode(signing.b62_encode(i)))