1 # Test hashlib module 2 # 3 # $Id$ 4 # 5 # Copyright (C) 2005-2010 Gregory P. Smith (greg (at] krypto.org) 6 # Licensed to PSF under a Contributor Agreement. 7 # 8 9 import array 10 from binascii import unhexlify 11 import hashlib 12 import itertools 13 import os 14 import sys 15 try: 16 import threading 17 except ImportError: 18 threading = None 19 import unittest 20 import warnings 21 from test import support 22 from test.support import _4G, bigmemtest, import_fresh_module 23 from http.client import HTTPException 24 25 # Were we compiled --with-pydebug or with #define Py_DEBUG? 26 COMPILED_WITH_PYDEBUG = hasattr(sys, 'gettotalrefcount') 27 28 c_hashlib = import_fresh_module('hashlib', fresh=['_hashlib']) 29 py_hashlib = import_fresh_module('hashlib', blocked=['_hashlib']) 30 31 try: 32 import _blake2 33 except ImportError: 34 _blake2 = None 35 36 requires_blake2 = unittest.skipUnless(_blake2, 'requires _blake2') 37 38 try: 39 import _sha3 40 except ImportError: 41 _sha3 = None 42 43 requires_sha3 = unittest.skipUnless(_sha3, 'requires _sha3') 44 45 46 def hexstr(s): 47 assert isinstance(s, bytes), repr(s) 48 h = "0123456789abcdef" 49 r = '' 50 for i in s: 51 r += h[(i >> 4) & 0xF] + h[i & 0xF] 52 return r 53 54 55 URL = "http://www.pythontest.net/hashlib/{}.txt" 56 57 def read_vectors(hash_name): 58 url = URL.format(hash_name) 59 try: 60 testdata = support.open_urlresource(url) 61 except (OSError, HTTPException): 62 raise unittest.SkipTest("Could not retrieve {}".format(url)) 63 with testdata: 64 for line in testdata: 65 line = line.strip() 66 if line.startswith('#') or not line: 67 continue 68 parts = line.split(',') 69 parts[0] = bytes.fromhex(parts[0]) 70 yield parts 71 72 73 class HashLibTestCase(unittest.TestCase): 74 supported_hash_names = ( 'md5', 'MD5', 'sha1', 'SHA1', 75 'sha224', 'SHA224', 'sha256', 'SHA256', 76 'sha384', 'SHA384', 'sha512', 'SHA512', 77 'blake2b', 'blake2s', 78 'sha3_224', 'sha3_256', 'sha3_384', 'sha3_512', 79 'shake_128', 'shake_256') 80 81 shakes = {'shake_128', 'shake_256'} 82 83 # Issue #14693: fallback modules are always compiled under POSIX 84 _warn_on_extension_import = os.name == 'posix' or COMPILED_WITH_PYDEBUG 85 86 def _conditional_import_module(self, module_name): 87 """Import a module and return a reference to it or None on failure.""" 88 try: 89 exec('import '+module_name) 90 except ImportError as error: 91 if self._warn_on_extension_import: 92 warnings.warn('Did a C extension fail to compile? %s' % error) 93 return locals().get(module_name) 94 95 def __init__(self, *args, **kwargs): 96 algorithms = set() 97 for algorithm in self.supported_hash_names: 98 algorithms.add(algorithm.lower()) 99 100 _blake2 = self._conditional_import_module('_blake2') 101 if _blake2: 102 algorithms.update({'blake2b', 'blake2s'}) 103 104 self.constructors_to_test = {} 105 for algorithm in algorithms: 106 self.constructors_to_test[algorithm] = set() 107 108 # For each algorithm, test the direct constructor and the use 109 # of hashlib.new given the algorithm name. 110 for algorithm, constructors in self.constructors_to_test.items(): 111 constructors.add(getattr(hashlib, algorithm)) 112 def _test_algorithm_via_hashlib_new(data=None, _alg=algorithm, **kwargs): 113 if data is None: 114 return hashlib.new(_alg, **kwargs) 115 return hashlib.new(_alg, data, **kwargs) 116 constructors.add(_test_algorithm_via_hashlib_new) 117 118 _hashlib = self._conditional_import_module('_hashlib') 119 if _hashlib: 120 # These two algorithms should always be present when this module 121 # is compiled. If not, something was compiled wrong. 122 self.assertTrue(hasattr(_hashlib, 'openssl_md5')) 123 self.assertTrue(hasattr(_hashlib, 'openssl_sha1')) 124 for algorithm, constructors in self.constructors_to_test.items(): 125 constructor = getattr(_hashlib, 'openssl_'+algorithm, None) 126 if constructor: 127 constructors.add(constructor) 128 129 def add_builtin_constructor(name): 130 constructor = getattr(hashlib, "__get_builtin_constructor")(name) 131 self.constructors_to_test[name].add(constructor) 132 133 _md5 = self._conditional_import_module('_md5') 134 if _md5: 135 add_builtin_constructor('md5') 136 _sha1 = self._conditional_import_module('_sha1') 137 if _sha1: 138 add_builtin_constructor('sha1') 139 _sha256 = self._conditional_import_module('_sha256') 140 if _sha256: 141 add_builtin_constructor('sha224') 142 add_builtin_constructor('sha256') 143 _sha512 = self._conditional_import_module('_sha512') 144 if _sha512: 145 add_builtin_constructor('sha384') 146 add_builtin_constructor('sha512') 147 if _blake2: 148 add_builtin_constructor('blake2s') 149 add_builtin_constructor('blake2b') 150 151 _sha3 = self._conditional_import_module('_sha3') 152 if _sha3: 153 add_builtin_constructor('sha3_224') 154 add_builtin_constructor('sha3_256') 155 add_builtin_constructor('sha3_384') 156 add_builtin_constructor('sha3_512') 157 add_builtin_constructor('shake_128') 158 add_builtin_constructor('shake_256') 159 160 super(HashLibTestCase, self).__init__(*args, **kwargs) 161 162 @property 163 def hash_constructors(self): 164 constructors = self.constructors_to_test.values() 165 return itertools.chain.from_iterable(constructors) 166 167 def test_hash_array(self): 168 a = array.array("b", range(10)) 169 for cons in self.hash_constructors: 170 c = cons(a) 171 if c.name in self.shakes: 172 c.hexdigest(16) 173 else: 174 c.hexdigest() 175 176 def test_algorithms_guaranteed(self): 177 self.assertEqual(hashlib.algorithms_guaranteed, 178 set(_algo for _algo in self.supported_hash_names 179 if _algo.islower())) 180 181 def test_algorithms_available(self): 182 self.assertTrue(set(hashlib.algorithms_guaranteed). 183 issubset(hashlib.algorithms_available)) 184 185 def test_unknown_hash(self): 186 self.assertRaises(ValueError, hashlib.new, 'spam spam spam spam spam') 187 self.assertRaises(TypeError, hashlib.new, 1) 188 189 def test_get_builtin_constructor(self): 190 get_builtin_constructor = getattr(hashlib, 191 '__get_builtin_constructor') 192 builtin_constructor_cache = getattr(hashlib, 193 '__builtin_constructor_cache') 194 self.assertRaises(ValueError, get_builtin_constructor, 'test') 195 try: 196 import _md5 197 except ImportError: 198 pass 199 # This forces an ImportError for "import _md5" statements 200 sys.modules['_md5'] = None 201 # clear the cache 202 builtin_constructor_cache.clear() 203 try: 204 self.assertRaises(ValueError, get_builtin_constructor, 'md5') 205 finally: 206 if '_md5' in locals(): 207 sys.modules['_md5'] = _md5 208 else: 209 del sys.modules['_md5'] 210 self.assertRaises(TypeError, get_builtin_constructor, 3) 211 constructor = get_builtin_constructor('md5') 212 self.assertIs(constructor, _md5.md5) 213 self.assertEqual(sorted(builtin_constructor_cache), ['MD5', 'md5']) 214 215 def test_hexdigest(self): 216 for cons in self.hash_constructors: 217 h = cons() 218 if h.name in self.shakes: 219 self.assertIsInstance(h.digest(16), bytes) 220 self.assertEqual(hexstr(h.digest(16)), h.hexdigest(16)) 221 else: 222 self.assertIsInstance(h.digest(), bytes) 223 self.assertEqual(hexstr(h.digest()), h.hexdigest()) 224 225 def test_name_attribute(self): 226 for cons in self.hash_constructors: 227 h = cons() 228 self.assertIsInstance(h.name, str) 229 if h.name in self.supported_hash_names: 230 self.assertIn(h.name, self.supported_hash_names) 231 else: 232 self.assertNotIn(h.name, self.supported_hash_names) 233 self.assertEqual(h.name, hashlib.new(h.name).name) 234 235 def test_large_update(self): 236 aas = b'a' * 128 237 bees = b'b' * 127 238 cees = b'c' * 126 239 dees = b'd' * 2048 # HASHLIB_GIL_MINSIZE 240 241 for cons in self.hash_constructors: 242 m1 = cons() 243 m1.update(aas) 244 m1.update(bees) 245 m1.update(cees) 246 m1.update(dees) 247 if m1.name in self.shakes: 248 args = (16,) 249 else: 250 args = () 251 252 m2 = cons() 253 m2.update(aas + bees + cees + dees) 254 self.assertEqual(m1.digest(*args), m2.digest(*args)) 255 256 m3 = cons(aas + bees + cees + dees) 257 self.assertEqual(m1.digest(*args), m3.digest(*args)) 258 259 # verify copy() doesn't touch original 260 m4 = cons(aas + bees + cees) 261 m4_digest = m4.digest(*args) 262 m4_copy = m4.copy() 263 m4_copy.update(dees) 264 self.assertEqual(m1.digest(*args), m4_copy.digest(*args)) 265 self.assertEqual(m4.digest(*args), m4_digest) 266 267 def check(self, name, data, hexdigest, shake=False, **kwargs): 268 length = len(hexdigest)//2 269 hexdigest = hexdigest.lower() 270 constructors = self.constructors_to_test[name] 271 # 2 is for hashlib.name(...) and hashlib.new(name, ...) 272 self.assertGreaterEqual(len(constructors), 2) 273 for hash_object_constructor in constructors: 274 m = hash_object_constructor(data, **kwargs) 275 computed = m.hexdigest() if not shake else m.hexdigest(length) 276 self.assertEqual( 277 computed, hexdigest, 278 "Hash algorithm %s constructed using %s returned hexdigest" 279 " %r for %d byte input data that should have hashed to %r." 280 % (name, hash_object_constructor, 281 computed, len(data), hexdigest)) 282 computed = m.digest() if not shake else m.digest(length) 283 digest = bytes.fromhex(hexdigest) 284 self.assertEqual(computed, digest) 285 if not shake: 286 self.assertEqual(len(digest), m.digest_size) 287 288 def check_no_unicode(self, algorithm_name): 289 # Unicode objects are not allowed as input. 290 constructors = self.constructors_to_test[algorithm_name] 291 for hash_object_constructor in constructors: 292 self.assertRaises(TypeError, hash_object_constructor, 'spam') 293 294 def test_no_unicode(self): 295 self.check_no_unicode('md5') 296 self.check_no_unicode('sha1') 297 self.check_no_unicode('sha224') 298 self.check_no_unicode('sha256') 299 self.check_no_unicode('sha384') 300 self.check_no_unicode('sha512') 301 302 @requires_blake2 303 def test_no_unicode_blake2(self): 304 self.check_no_unicode('blake2b') 305 self.check_no_unicode('blake2s') 306 307 @requires_sha3 308 def test_no_unicode_sha3(self): 309 self.check_no_unicode('sha3_224') 310 self.check_no_unicode('sha3_256') 311 self.check_no_unicode('sha3_384') 312 self.check_no_unicode('sha3_512') 313 self.check_no_unicode('shake_128') 314 self.check_no_unicode('shake_256') 315 316 def check_blocksize_name(self, name, block_size=0, digest_size=0, 317 digest_length=None): 318 constructors = self.constructors_to_test[name] 319 for hash_object_constructor in constructors: 320 m = hash_object_constructor() 321 self.assertEqual(m.block_size, block_size) 322 self.assertEqual(m.digest_size, digest_size) 323 if digest_length: 324 self.assertEqual(len(m.digest(digest_length)), 325 digest_length) 326 self.assertEqual(len(m.hexdigest(digest_length)), 327 2*digest_length) 328 else: 329 self.assertEqual(len(m.digest()), digest_size) 330 self.assertEqual(len(m.hexdigest()), 2*digest_size) 331 self.assertEqual(m.name, name) 332 # split for sha3_512 / _sha3.sha3 object 333 self.assertIn(name.split("_")[0], repr(m)) 334 335 def test_blocksize_name(self): 336 self.check_blocksize_name('md5', 64, 16) 337 self.check_blocksize_name('sha1', 64, 20) 338 self.check_blocksize_name('sha224', 64, 28) 339 self.check_blocksize_name('sha256', 64, 32) 340 self.check_blocksize_name('sha384', 128, 48) 341 self.check_blocksize_name('sha512', 128, 64) 342 343 @requires_sha3 344 def test_blocksize_name_sha3(self): 345 self.check_blocksize_name('sha3_224', 144, 28) 346 self.check_blocksize_name('sha3_256', 136, 32) 347 self.check_blocksize_name('sha3_384', 104, 48) 348 self.check_blocksize_name('sha3_512', 72, 64) 349 self.check_blocksize_name('shake_128', 168, 0, 32) 350 self.check_blocksize_name('shake_256', 136, 0, 64) 351 352 def check_sha3(self, name, capacity, rate, suffix): 353 constructors = self.constructors_to_test[name] 354 for hash_object_constructor in constructors: 355 m = hash_object_constructor() 356 self.assertEqual(capacity + rate, 1600) 357 self.assertEqual(m._capacity_bits, capacity) 358 self.assertEqual(m._rate_bits, rate) 359 self.assertEqual(m._suffix, suffix) 360 361 @requires_sha3 362 def test_extra_sha3(self): 363 self.check_sha3('sha3_224', 448, 1152, b'\x06') 364 self.check_sha3('sha3_256', 512, 1088, b'\x06') 365 self.check_sha3('sha3_384', 768, 832, b'\x06') 366 self.check_sha3('sha3_512', 1024, 576, b'\x06') 367 self.check_sha3('shake_128', 256, 1344, b'\x1f') 368 self.check_sha3('shake_256', 512, 1088, b'\x1f') 369 370 @requires_blake2 371 def test_blocksize_name_blake2(self): 372 self.check_blocksize_name('blake2b', 128, 64) 373 self.check_blocksize_name('blake2s', 64, 32) 374 375 def test_case_md5_0(self): 376 self.check('md5', b'', 'd41d8cd98f00b204e9800998ecf8427e') 377 378 def test_case_md5_1(self): 379 self.check('md5', b'abc', '900150983cd24fb0d6963f7d28e17f72') 380 381 def test_case_md5_2(self): 382 self.check('md5', 383 b'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789', 384 'd174ab98d277d9f5a5611c2c9f419d9f') 385 386 @unittest.skipIf(sys.maxsize < _4G + 5, 'test cannot run on 32-bit systems') 387 @bigmemtest(size=_4G + 5, memuse=1, dry_run=False) 388 def test_case_md5_huge(self, size): 389 self.check('md5', b'A'*size, 'c9af2dff37468ce5dfee8f2cfc0a9c6d') 390 391 @unittest.skipIf(sys.maxsize < _4G - 1, 'test cannot run on 32-bit systems') 392 @bigmemtest(size=_4G - 1, memuse=1, dry_run=False) 393 def test_case_md5_uintmax(self, size): 394 self.check('md5', b'A'*size, '28138d306ff1b8281f1a9067e1a1a2b3') 395 396 # use the three examples from Federal Information Processing Standards 397 # Publication 180-1, Secure Hash Standard, 1995 April 17 398 # http://www.itl.nist.gov/div897/pubs/fip180-1.htm 399 400 def test_case_sha1_0(self): 401 self.check('sha1', b"", 402 "da39a3ee5e6b4b0d3255bfef95601890afd80709") 403 404 def test_case_sha1_1(self): 405 self.check('sha1', b"abc", 406 "a9993e364706816aba3e25717850c26c9cd0d89d") 407 408 def test_case_sha1_2(self): 409 self.check('sha1', 410 b"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", 411 "84983e441c3bd26ebaae4aa1f95129e5e54670f1") 412 413 def test_case_sha1_3(self): 414 self.check('sha1', b"a" * 1000000, 415 "34aa973cd4c4daa4f61eeb2bdbad27316534016f") 416 417 418 # use the examples from Federal Information Processing Standards 419 # Publication 180-2, Secure Hash Standard, 2002 August 1 420 # http://csrc.nist.gov/publications/fips/fips180-2/fips180-2.pdf 421 422 def test_case_sha224_0(self): 423 self.check('sha224', b"", 424 "d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f") 425 426 def test_case_sha224_1(self): 427 self.check('sha224', b"abc", 428 "23097d223405d8228642a477bda255b32aadbce4bda0b3f7e36c9da7") 429 430 def test_case_sha224_2(self): 431 self.check('sha224', 432 b"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", 433 "75388b16512776cc5dba5da1fd890150b0c6455cb4f58b1952522525") 434 435 def test_case_sha224_3(self): 436 self.check('sha224', b"a" * 1000000, 437 "20794655980c91d8bbb4c1ea97618a4bf03f42581948b2ee4ee7ad67") 438 439 440 def test_case_sha256_0(self): 441 self.check('sha256', b"", 442 "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855") 443 444 def test_case_sha256_1(self): 445 self.check('sha256', b"abc", 446 "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad") 447 448 def test_case_sha256_2(self): 449 self.check('sha256', 450 b"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", 451 "248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1") 452 453 def test_case_sha256_3(self): 454 self.check('sha256', b"a" * 1000000, 455 "cdc76e5c9914fb9281a1c7e284d73e67f1809a48a497200e046d39ccc7112cd0") 456 457 458 def test_case_sha384_0(self): 459 self.check('sha384', b"", 460 "38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da"+ 461 "274edebfe76f65fbd51ad2f14898b95b") 462 463 def test_case_sha384_1(self): 464 self.check('sha384', b"abc", 465 "cb00753f45a35e8bb5a03d699ac65007272c32ab0eded1631a8b605a43ff5bed"+ 466 "8086072ba1e7cc2358baeca134c825a7") 467 468 def test_case_sha384_2(self): 469 self.check('sha384', 470 b"abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmn"+ 471 b"hijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu", 472 "09330c33f71147e83d192fc782cd1b4753111b173b3b05d22fa08086e3b0f712"+ 473 "fcc7c71a557e2db966c3e9fa91746039") 474 475 def test_case_sha384_3(self): 476 self.check('sha384', b"a" * 1000000, 477 "9d0e1809716474cb086e834e310a4a1ced149e9c00f248527972cec5704c2a5b"+ 478 "07b8b3dc38ecc4ebae97ddd87f3d8985") 479 480 481 def test_case_sha512_0(self): 482 self.check('sha512', b"", 483 "cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce"+ 484 "47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e") 485 486 def test_case_sha512_1(self): 487 self.check('sha512', b"abc", 488 "ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a"+ 489 "2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f") 490 491 def test_case_sha512_2(self): 492 self.check('sha512', 493 b"abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmn"+ 494 b"hijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu", 495 "8e959b75dae313da8cf4f72814fc143f8f7779c6eb9f7fa17299aeadb6889018"+ 496 "501d289e4900f7e4331b99dec4b5433ac7d329eeb6dd26545e96e55b874be909") 497 498 def test_case_sha512_3(self): 499 self.check('sha512', b"a" * 1000000, 500 "e718483d0ce769644e2e42c7bc15b4638e1f98b13b2044285632a803afa973eb"+ 501 "de0ff244877ea60a4cb0432ce577c31beb009c5c2c49aa2e4eadb217ad8cc09b") 502 503 def check_blake2(self, constructor, salt_size, person_size, key_size, 504 digest_size, max_offset): 505 self.assertEqual(constructor.SALT_SIZE, salt_size) 506 for i in range(salt_size + 1): 507 constructor(salt=b'a' * i) 508 salt = b'a' * (salt_size + 1) 509 self.assertRaises(ValueError, constructor, salt=salt) 510 511 self.assertEqual(constructor.PERSON_SIZE, person_size) 512 for i in range(person_size+1): 513 constructor(person=b'a' * i) 514 person = b'a' * (person_size + 1) 515 self.assertRaises(ValueError, constructor, person=person) 516 517 self.assertEqual(constructor.MAX_DIGEST_SIZE, digest_size) 518 for i in range(1, digest_size + 1): 519 constructor(digest_size=i) 520 self.assertRaises(ValueError, constructor, digest_size=-1) 521 self.assertRaises(ValueError, constructor, digest_size=0) 522 self.assertRaises(ValueError, constructor, digest_size=digest_size+1) 523 524 self.assertEqual(constructor.MAX_KEY_SIZE, key_size) 525 for i in range(key_size+1): 526 constructor(key=b'a' * i) 527 key = b'a' * (key_size + 1) 528 self.assertRaises(ValueError, constructor, key=key) 529 self.assertEqual(constructor().hexdigest(), 530 constructor(key=b'').hexdigest()) 531 532 for i in range(0, 256): 533 constructor(fanout=i) 534 self.assertRaises(ValueError, constructor, fanout=-1) 535 self.assertRaises(ValueError, constructor, fanout=256) 536 537 for i in range(1, 256): 538 constructor(depth=i) 539 self.assertRaises(ValueError, constructor, depth=-1) 540 self.assertRaises(ValueError, constructor, depth=0) 541 self.assertRaises(ValueError, constructor, depth=256) 542 543 for i in range(0, 256): 544 constructor(node_depth=i) 545 self.assertRaises(ValueError, constructor, node_depth=-1) 546 self.assertRaises(ValueError, constructor, node_depth=256) 547 548 for i in range(0, digest_size + 1): 549 constructor(inner_size=i) 550 self.assertRaises(ValueError, constructor, inner_size=-1) 551 self.assertRaises(ValueError, constructor, inner_size=digest_size+1) 552 553 constructor(leaf_size=0) 554 constructor(leaf_size=(1<<32)-1) 555 self.assertRaises(OverflowError, constructor, leaf_size=-1) 556 self.assertRaises(OverflowError, constructor, leaf_size=1<<32) 557 558 constructor(node_offset=0) 559 constructor(node_offset=max_offset) 560 self.assertRaises(OverflowError, constructor, node_offset=-1) 561 self.assertRaises(OverflowError, constructor, node_offset=max_offset+1) 562 563 constructor( 564 string=b'', 565 key=b'', 566 salt=b'', 567 person=b'', 568 digest_size=17, 569 fanout=1, 570 depth=1, 571 leaf_size=256, 572 node_offset=512, 573 node_depth=1, 574 inner_size=7, 575 last_node=True 576 ) 577 578 def blake2_rfc7693(self, constructor, md_len, in_len): 579 def selftest_seq(length, seed): 580 mask = (1<<32)-1 581 a = (0xDEAD4BAD * seed) & mask 582 b = 1 583 out = bytearray(length) 584 for i in range(length): 585 t = (a + b) & mask 586 a, b = b, t 587 out[i] = (t >> 24) & 0xFF 588 return out 589 outer = constructor(digest_size=32) 590 for outlen in md_len: 591 for inlen in in_len: 592 indata = selftest_seq(inlen, inlen) 593 key = selftest_seq(outlen, outlen) 594 unkeyed = constructor(indata, digest_size=outlen) 595 outer.update(unkeyed.digest()) 596 keyed = constructor(indata, key=key, digest_size=outlen) 597 outer.update(keyed.digest()) 598 return outer.hexdigest() 599 600 @requires_blake2 601 def test_blake2b(self): 602 self.check_blake2(hashlib.blake2b, 16, 16, 64, 64, (1<<64)-1) 603 b2b_md_len = [20, 32, 48, 64] 604 b2b_in_len = [0, 3, 128, 129, 255, 1024] 605 self.assertEqual( 606 self.blake2_rfc7693(hashlib.blake2b, b2b_md_len, b2b_in_len), 607 "c23a7800d98123bd10f506c61e29da5603d763b8bbad2e737f5e765a7bccd475") 608 609 @requires_blake2 610 def test_case_blake2b_0(self): 611 self.check('blake2b', b"", 612 "786a02f742015903c6c6fd852552d272912f4740e15847618a86e217f71f5419"+ 613 "d25e1031afee585313896444934eb04b903a685b1448b755d56f701afe9be2ce") 614 615 @requires_blake2 616 def test_case_blake2b_1(self): 617 self.check('blake2b', b"abc", 618 "ba80a53f981c4d0d6a2797b69f12f6e94c212f14685ac4b74b12bb6fdbffa2d1"+ 619 "7d87c5392aab792dc252d5de4533cc9518d38aa8dbf1925ab92386edd4009923") 620 621 @requires_blake2 622 def test_blake2b_vectors(self): 623 for msg, key, md in read_vectors('blake2b'): 624 key = bytes.fromhex(key) 625 self.check('blake2b', msg, md, key=key) 626 627 @requires_blake2 628 def test_blake2s(self): 629 self.check_blake2(hashlib.blake2s, 8, 8, 32, 32, (1<<48)-1) 630 b2s_md_len = [16, 20, 28, 32] 631 b2s_in_len = [0, 3, 64, 65, 255, 1024] 632 self.assertEqual( 633 self.blake2_rfc7693(hashlib.blake2s, b2s_md_len, b2s_in_len), 634 "6a411f08ce25adcdfb02aba641451cec53c598b24f4fc787fbdc88797f4c1dfe") 635 636 @requires_blake2 637 def test_case_blake2s_0(self): 638 self.check('blake2s', b"", 639 "69217a3079908094e11121d042354a7c1f55b6482ca1a51e1b250dfd1ed0eef9") 640 641 @requires_blake2 642 def test_case_blake2s_1(self): 643 self.check('blake2s', b"abc", 644 "508c5e8c327c14e2e1a72ba34eeb452f37458b209ed63a294d999b4c86675982") 645 646 @requires_blake2 647 def test_blake2s_vectors(self): 648 for msg, key, md in read_vectors('blake2s'): 649 key = bytes.fromhex(key) 650 self.check('blake2s', msg, md, key=key) 651 652 @requires_sha3 653 def test_case_sha3_224_0(self): 654 self.check('sha3_224', b"", 655 "6b4e03423667dbb73b6e15454f0eb1abd4597f9a1b078e3f5b5a6bc7") 656 657 @requires_sha3 658 def test_case_sha3_224_vector(self): 659 for msg, md in read_vectors('sha3_224'): 660 self.check('sha3_224', msg, md) 661 662 @requires_sha3 663 def test_case_sha3_256_0(self): 664 self.check('sha3_256', b"", 665 "a7ffc6f8bf1ed76651c14756a061d662f580ff4de43b49fa82d80a4b80f8434a") 666 667 @requires_sha3 668 def test_case_sha3_256_vector(self): 669 for msg, md in read_vectors('sha3_256'): 670 self.check('sha3_256', msg, md) 671 672 @requires_sha3 673 def test_case_sha3_384_0(self): 674 self.check('sha3_384', b"", 675 "0c63a75b845e4f7d01107d852e4c2485c51a50aaaa94fc61995e71bbee983a2a"+ 676 "c3713831264adb47fb6bd1e058d5f004") 677 678 @requires_sha3 679 def test_case_sha3_384_vector(self): 680 for msg, md in read_vectors('sha3_384'): 681 self.check('sha3_384', msg, md) 682 683 @requires_sha3 684 def test_case_sha3_512_0(self): 685 self.check('sha3_512', b"", 686 "a69f73cca23a9ac5c8b567dc185a756e97c982164fe25859e0d1dcc1475c80a6"+ 687 "15b2123af1f5f94c11e3e9402c3ac558f500199d95b6d3e301758586281dcd26") 688 689 @requires_sha3 690 def test_case_sha3_512_vector(self): 691 for msg, md in read_vectors('sha3_512'): 692 self.check('sha3_512', msg, md) 693 694 @requires_sha3 695 def test_case_shake_128_0(self): 696 self.check('shake_128', b"", 697 "7f9c2ba4e88f827d616045507605853ed73b8093f6efbc88eb1a6eacfa66ef26", 698 True) 699 self.check('shake_128', b"", "7f9c", True) 700 701 @requires_sha3 702 def test_case_shake128_vector(self): 703 for msg, md in read_vectors('shake_128'): 704 self.check('shake_128', msg, md, True) 705 706 @requires_sha3 707 def test_case_shake_256_0(self): 708 self.check('shake_256', b"", 709 "46b9dd2b0ba88d13233b3feb743eeb243fcd52ea62b81b82b50c27646ed5762f", 710 True) 711 self.check('shake_256', b"", "46b9", True) 712 713 @requires_sha3 714 def test_case_shake256_vector(self): 715 for msg, md in read_vectors('shake_256'): 716 self.check('shake_256', msg, md, True) 717 718 def test_gil(self): 719 # Check things work fine with an input larger than the size required 720 # for multithreaded operation (which is hardwired to 2048). 721 gil_minsize = 2048 722 723 for cons in self.hash_constructors: 724 m = cons() 725 m.update(b'1') 726 m.update(b'#' * gil_minsize) 727 m.update(b'1') 728 729 m = cons(b'x' * gil_minsize) 730 m.update(b'1') 731 732 m = hashlib.md5() 733 m.update(b'1') 734 m.update(b'#' * gil_minsize) 735 m.update(b'1') 736 self.assertEqual(m.hexdigest(), 'cb1e1a2cbc80be75e19935d621fb9b21') 737 738 m = hashlib.md5(b'x' * gil_minsize) 739 self.assertEqual(m.hexdigest(), 'cfb767f225d58469c5de3632a8803958') 740 741 @unittest.skipUnless(threading, 'Threading required for this test.') 742 @support.reap_threads 743 def test_threaded_hashing(self): 744 # Updating the same hash object from several threads at once 745 # using data chunk sizes containing the same byte sequences. 746 # 747 # If the internal locks are working to prevent multiple 748 # updates on the same object from running at once, the resulting 749 # hash will be the same as doing it single threaded upfront. 750 hasher = hashlib.sha1() 751 num_threads = 5 752 smallest_data = b'swineflu' 753 data = smallest_data*200000 754 expected_hash = hashlib.sha1(data*num_threads).hexdigest() 755 756 def hash_in_chunks(chunk_size, event): 757 index = 0 758 while index < len(data): 759 hasher.update(data[index:index+chunk_size]) 760 index += chunk_size 761 event.set() 762 763 events = [] 764 for threadnum in range(num_threads): 765 chunk_size = len(data) // (10**threadnum) 766 self.assertGreater(chunk_size, 0) 767 self.assertEqual(chunk_size % len(smallest_data), 0) 768 event = threading.Event() 769 events.append(event) 770 threading.Thread(target=hash_in_chunks, 771 args=(chunk_size, event)).start() 772 773 for event in events: 774 event.wait() 775 776 self.assertEqual(expected_hash, hasher.hexdigest()) 777 778 779 class KDFTests(unittest.TestCase): 780 781 pbkdf2_test_vectors = [ 782 (b'password', b'salt', 1, None), 783 (b'password', b'salt', 2, None), 784 (b'password', b'salt', 4096, None), 785 # too slow, it takes over a minute on a fast CPU. 786 #(b'password', b'salt', 16777216, None), 787 (b'passwordPASSWORDpassword', b'saltSALTsaltSALTsaltSALTsaltSALTsalt', 788 4096, -1), 789 (b'pass\0word', b'sa\0lt', 4096, 16), 790 ] 791 792 scrypt_test_vectors = [ 793 (b'', b'', 16, 1, 1, unhexlify('77d6576238657b203b19ca42c18a0497f16b4844e3074ae8dfdffa3fede21442fcd0069ded0948f8326a753a0fc81f17e8d3e0fb2e0d3628cf35e20c38d18906')), 794 (b'password', b'NaCl', 1024, 8, 16, unhexlify('fdbabe1c9d3472007856e7190d01e9fe7c6ad7cbc8237830e77376634b3731622eaf30d92e22a3886ff109279d9830dac727afb94a83ee6d8360cbdfa2cc0640')), 795 (b'pleaseletmein', b'SodiumChloride', 16384, 8, 1, unhexlify('7023bdcb3afd7348461c06cd81fd38ebfda8fbba904f8e3ea9b543f6545da1f2d5432955613f0fcf62d49705242a9af9e61e85dc0d651e40dfcf017b45575887')), 796 ] 797 798 pbkdf2_results = { 799 "sha1": [ 800 # official test vectors from RFC 6070 801 (bytes.fromhex('0c60c80f961f0e71f3a9b524af6012062fe037a6'), None), 802 (bytes.fromhex('ea6c014dc72d6f8ccd1ed92ace1d41f0d8de8957'), None), 803 (bytes.fromhex('4b007901b765489abead49d926f721d065a429c1'), None), 804 #(bytes.fromhex('eefe3d61cd4da4e4e9945b3d6ba2158c2634e984'), None), 805 (bytes.fromhex('3d2eec4fe41c849b80c8d83662c0e44a8b291a964c' 806 'f2f07038'), 25), 807 (bytes.fromhex('56fa6aa75548099dcc37d7f03425e0c3'), None),], 808 "sha256": [ 809 (bytes.fromhex('120fb6cffcf8b32c43e7225256c4f837' 810 'a86548c92ccc35480805987cb70be17b'), None), 811 (bytes.fromhex('ae4d0c95af6b46d32d0adff928f06dd0' 812 '2a303f8ef3c251dfd6e2d85a95474c43'), None), 813 (bytes.fromhex('c5e478d59288c841aa530db6845c4c8d' 814 '962893a001ce4e11a4963873aa98134a'), None), 815 #(bytes.fromhex('cf81c66fe8cfc04d1f31ecb65dab4089' 816 # 'f7f179e89b3b0bcb17ad10e3ac6eba46'), None), 817 (bytes.fromhex('348c89dbcbd32b2f32d814b8116e84cf2b17' 818 '347ebc1800181c4e2a1fb8dd53e1c635518c7dac47e9'), 40), 819 (bytes.fromhex('89b69d0516f829893c696226650a8687'), None),], 820 "sha512": [ 821 (bytes.fromhex('867f70cf1ade02cff3752599a3a53dc4af34c7a669815ae5' 822 'd513554e1c8cf252c02d470a285a0501bad999bfe943c08f' 823 '050235d7d68b1da55e63f73b60a57fce'), None), 824 (bytes.fromhex('e1d9c16aa681708a45f5c7c4e215ceb66e011a2e9f004071' 825 '3f18aefdb866d53cf76cab2868a39b9f7840edce4fef5a82' 826 'be67335c77a6068e04112754f27ccf4e'), None), 827 (bytes.fromhex('d197b1b33db0143e018b12f3d1d1479e6cdebdcc97c5c0f8' 828 '7f6902e072f457b5143f30602641b3d55cd335988cb36b84' 829 '376060ecd532e039b742a239434af2d5'), None), 830 (bytes.fromhex('8c0511f4c6e597c6ac6315d8f0362e225f3c501495ba23b8' 831 '68c005174dc4ee71115b59f9e60cd9532fa33e0f75aefe30' 832 '225c583a186cd82bd4daea9724a3d3b8'), 64), 833 (bytes.fromhex('9d9e9c4cd21fe4be24d5b8244c759665'), None),], 834 } 835 836 def _test_pbkdf2_hmac(self, pbkdf2): 837 for digest_name, results in self.pbkdf2_results.items(): 838 for i, vector in enumerate(self.pbkdf2_test_vectors): 839 password, salt, rounds, dklen = vector 840 expected, overwrite_dklen = results[i] 841 if overwrite_dklen: 842 dklen = overwrite_dklen 843 out = pbkdf2(digest_name, password, salt, rounds, dklen) 844 self.assertEqual(out, expected, 845 (digest_name, password, salt, rounds, dklen)) 846 out = pbkdf2(digest_name, memoryview(password), 847 memoryview(salt), rounds, dklen) 848 out = pbkdf2(digest_name, bytearray(password), 849 bytearray(salt), rounds, dklen) 850 self.assertEqual(out, expected) 851 if dklen is None: 852 out = pbkdf2(digest_name, password, salt, rounds) 853 self.assertEqual(out, expected, 854 (digest_name, password, salt, rounds)) 855 856 self.assertRaises(TypeError, pbkdf2, b'sha1', b'pass', b'salt', 1) 857 self.assertRaises(TypeError, pbkdf2, 'sha1', 'pass', 'salt', 1) 858 self.assertRaises(ValueError, pbkdf2, 'sha1', b'pass', b'salt', 0) 859 self.assertRaises(ValueError, pbkdf2, 'sha1', b'pass', b'salt', -1) 860 self.assertRaises(ValueError, pbkdf2, 'sha1', b'pass', b'salt', 1, 0) 861 self.assertRaises(ValueError, pbkdf2, 'sha1', b'pass', b'salt', 1, -1) 862 with self.assertRaisesRegex(ValueError, 'unsupported hash type'): 863 pbkdf2('unknown', b'pass', b'salt', 1) 864 out = pbkdf2(hash_name='sha1', password=b'password', salt=b'salt', 865 iterations=1, dklen=None) 866 self.assertEqual(out, self.pbkdf2_results['sha1'][0][0]) 867 868 def test_pbkdf2_hmac_py(self): 869 self._test_pbkdf2_hmac(py_hashlib.pbkdf2_hmac) 870 871 @unittest.skipUnless(hasattr(c_hashlib, 'pbkdf2_hmac'), 872 ' test requires OpenSSL > 1.0') 873 def test_pbkdf2_hmac_c(self): 874 self._test_pbkdf2_hmac(c_hashlib.pbkdf2_hmac) 875 876 877 @unittest.skipUnless(hasattr(c_hashlib, 'scrypt'), 878 ' test requires OpenSSL > 1.1') 879 def test_scrypt(self): 880 for password, salt, n, r, p, expected in self.scrypt_test_vectors: 881 result = hashlib.scrypt(password, salt=salt, n=n, r=r, p=p) 882 self.assertEqual(result, expected) 883 884 # this values should work 885 hashlib.scrypt(b'password', salt=b'salt', n=2, r=8, p=1) 886 # password and salt must be bytes-like 887 with self.assertRaises(TypeError): 888 hashlib.scrypt('password', salt=b'salt', n=2, r=8, p=1) 889 with self.assertRaises(TypeError): 890 hashlib.scrypt(b'password', salt='salt', n=2, r=8, p=1) 891 # require keyword args 892 with self.assertRaises(TypeError): 893 hashlib.scrypt(b'password') 894 with self.assertRaises(TypeError): 895 hashlib.scrypt(b'password', b'salt') 896 with self.assertRaises(TypeError): 897 hashlib.scrypt(b'password', 2, 8, 1, salt=b'salt') 898 for n in [-1, 0, 1, None]: 899 with self.assertRaises((ValueError, OverflowError, TypeError)): 900 hashlib.scrypt(b'password', salt=b'salt', n=n, r=8, p=1) 901 for r in [-1, 0, None]: 902 with self.assertRaises((ValueError, OverflowError, TypeError)): 903 hashlib.scrypt(b'password', salt=b'salt', n=2, r=r, p=1) 904 for p in [-1, 0, None]: 905 with self.assertRaises((ValueError, OverflowError, TypeError)): 906 hashlib.scrypt(b'password', salt=b'salt', n=2, r=8, p=p) 907 for maxmem in [-1, None]: 908 with self.assertRaises((ValueError, OverflowError, TypeError)): 909 hashlib.scrypt(b'password', salt=b'salt', n=2, r=8, p=1, 910 maxmem=maxmem) 911 for dklen in [-1, None]: 912 with self.assertRaises((ValueError, OverflowError, TypeError)): 913 hashlib.scrypt(b'password', salt=b'salt', n=2, r=8, p=1, 914 dklen=dklen) 915 916 917 if __name__ == "__main__": 918 unittest.main() 919
