diff options
author | Sybren A. Stüvel <sybren@stuvel.eu> | 2021-03-29 23:17:55 +0200 |
---|---|---|
committer | Sybren A. Stüvel <sybren@stuvel.eu> | 2021-03-29 23:17:55 +0200 |
commit | 35e962d9ce424ef5ea35a9787b7b165fc034712d (patch) | |
tree | d2f93be0eb8e288ce4c2021527ddd9e57489ca7c /tests | |
parent | 7bdbdaa16ee644d00845b94eaa3008061dc5ec79 (diff) | |
download | rsa-git-35e962d9ce424ef5ea35a9787b7b165fc034712d.tar.gz |
Reformatting with Black
No functional changes.
Diffstat (limited to 'tests')
-rw-r--r-- | tests/test_cli.py | 127 | ||||
-rw-r--r-- | tests/test_common.py | 18 | ||||
-rw-r--r-- | tests/test_compat.py | 46 | ||||
-rw-r--r-- | tests/test_load_save_keys.py | 72 | ||||
-rw-r--r-- | tests/test_mypy.py | 14 | ||||
-rw-r--r-- | tests/test_pem.py | 39 | ||||
-rw-r--r-- | tests/test_pkcs1.py | 87 | ||||
-rw-r--r-- | tests/test_pkcs1_v2.py | 52 | ||||
-rw-r--r-- | tests/test_prime.py | 54 | ||||
-rw-r--r-- | tests/test_strings.py | 2 | ||||
-rw-r--r-- | tests/test_transform.py | 17 |
11 files changed, 286 insertions, 242 deletions
diff --git a/tests/test_cli.py b/tests/test_cli.py index 00f77ac..bb872ea 100644 --- a/tests/test_cli.py +++ b/tests/test_cli.py @@ -83,20 +83,20 @@ class AbstractCliTest(unittest.TestCase): def setUpClass(cls): # Ensure there is a key to use cls.pub_key, cls.priv_key = rsa.newkeys(512) - cls.pub_fname = '%s.pub' % cls.__name__ - cls.priv_fname = '%s.key' % cls.__name__ + cls.pub_fname = "%s.pub" % cls.__name__ + cls.priv_fname = "%s.key" % cls.__name__ - with open(cls.pub_fname, 'wb') as outfile: + with open(cls.pub_fname, "wb") as outfile: outfile.write(cls.pub_key.save_pkcs1()) - with open(cls.priv_fname, 'wb') as outfile: + with open(cls.priv_fname, "wb") as outfile: outfile.write(cls.priv_key.save_pkcs1()) @classmethod def tearDownClass(cls): - if hasattr(cls, 'pub_fname'): + if hasattr(cls, "pub_fname"): remove_if_exists(cls.pub_fname) - if hasattr(cls, 'priv_fname'): + if hasattr(cls, "priv_fname"): remove_if_exists(cls.priv_fname) def assertExits(self, status_code, func, *args, **kwargs): @@ -105,10 +105,12 @@ class AbstractCliTest(unittest.TestCase): except SystemExit as ex: if status_code == ex.code: return - self.fail('SystemExit() raised by %r, but exited with code %r, expected %r' % ( - func, ex.code, status_code)) + self.fail( + "SystemExit() raised by %r, but exited with code %r, expected %r" + % (func, ex.code, status_code) + ) else: - self.fail('SystemExit() not raised by %r' % func) + self.fail("SystemExit() not raised by %r" % func) class KeygenTest(AbstractCliTest): @@ -122,61 +124,64 @@ class KeygenTest(AbstractCliTest): rsa.cli.keygen() lines = get_bytes_out(out).splitlines() - self.assertEqual(b'-----BEGIN RSA PRIVATE KEY-----', lines[0]) - self.assertEqual(b'-----END RSA PRIVATE KEY-----', lines[-1]) + self.assertEqual(b"-----BEGIN RSA PRIVATE KEY-----", lines[0]) + self.assertEqual(b"-----END RSA PRIVATE KEY-----", lines[-1]) # The key size should be shown on stderr - self.assertTrue('128-bit key' in err.getvalue()) + self.assertTrue("128-bit key" in err.getvalue()) - @cleanup_files('test_cli_privkey_out.pem') + @cleanup_files("test_cli_privkey_out.pem") def test_keygen_priv_out_pem(self): with captured_output() as (out, err): - with cli_args('--out=test_cli_privkey_out.pem', '--form=PEM', 128): + with cli_args("--out=test_cli_privkey_out.pem", "--form=PEM", 128): rsa.cli.keygen() # The key size should be shown on stderr - self.assertTrue('128-bit key' in err.getvalue()) + self.assertTrue("128-bit key" in err.getvalue()) # The output file should be shown on stderr - self.assertTrue('test_cli_privkey_out.pem' in err.getvalue()) + self.assertTrue("test_cli_privkey_out.pem" in err.getvalue()) # If we can load the file as PEM, it's good enough. - with open('test_cli_privkey_out.pem', 'rb') as pemfile: + with open("test_cli_privkey_out.pem", "rb") as pemfile: rsa.PrivateKey.load_pkcs1(pemfile.read()) - @cleanup_files('test_cli_privkey_out.der') + @cleanup_files("test_cli_privkey_out.der") def test_keygen_priv_out_der(self): with captured_output() as (out, err): - with cli_args('--out=test_cli_privkey_out.der', '--form=DER', 128): + with cli_args("--out=test_cli_privkey_out.der", "--form=DER", 128): rsa.cli.keygen() # The key size should be shown on stderr - self.assertTrue('128-bit key' in err.getvalue()) + self.assertTrue("128-bit key" in err.getvalue()) # The output file should be shown on stderr - self.assertTrue('test_cli_privkey_out.der' in err.getvalue()) + self.assertTrue("test_cli_privkey_out.der" in err.getvalue()) # If we can load the file as der, it's good enough. - with open('test_cli_privkey_out.der', 'rb') as derfile: - rsa.PrivateKey.load_pkcs1(derfile.read(), format='DER') + with open("test_cli_privkey_out.der", "rb") as derfile: + rsa.PrivateKey.load_pkcs1(derfile.read(), format="DER") - @cleanup_files('test_cli_privkey_out.pem', 'test_cli_pubkey_out.pem') + @cleanup_files("test_cli_privkey_out.pem", "test_cli_pubkey_out.pem") def test_keygen_pub_out_pem(self): with captured_output() as (out, err): - with cli_args('--out=test_cli_privkey_out.pem', - '--pubout=test_cli_pubkey_out.pem', - '--form=PEM', 256): + with cli_args( + "--out=test_cli_privkey_out.pem", + "--pubout=test_cli_pubkey_out.pem", + "--form=PEM", + 256, + ): rsa.cli.keygen() # The key size should be shown on stderr - self.assertTrue('256-bit key' in err.getvalue()) + self.assertTrue("256-bit key" in err.getvalue()) # The output files should be shown on stderr - self.assertTrue('test_cli_privkey_out.pem' in err.getvalue()) - self.assertTrue('test_cli_pubkey_out.pem' in err.getvalue()) + self.assertTrue("test_cli_privkey_out.pem" in err.getvalue()) + self.assertTrue("test_cli_pubkey_out.pem" in err.getvalue()) # If we can load the file as PEM, it's good enough. - with open('test_cli_pubkey_out.pem', 'rb') as pemfile: + with open("test_cli_pubkey_out.pem", "rb") as pemfile: rsa.PublicKey.load_pkcs1(pemfile.read()) @@ -189,38 +194,38 @@ class EncryptDecryptTest(AbstractCliTest): with captured_output(), cli_args(): self.assertExits(1, rsa.cli.encrypt) - @cleanup_files('encrypted.txt', 'cleartext.txt') + @cleanup_files("encrypted.txt", "cleartext.txt") def test_encrypt_decrypt(self): - with open('cleartext.txt', 'wb') as outfile: - outfile.write(b'Hello cleartext RSA users!') + with open("cleartext.txt", "wb") as outfile: + outfile.write(b"Hello cleartext RSA users!") - with cli_args('-i', 'cleartext.txt', '--out=encrypted.txt', self.pub_fname): + with cli_args("-i", "cleartext.txt", "--out=encrypted.txt", self.pub_fname): with captured_output(): rsa.cli.encrypt() - with cli_args('-i', 'encrypted.txt', self.priv_fname): + with cli_args("-i", "encrypted.txt", self.priv_fname): with captured_output() as (out, err): rsa.cli.decrypt() # We should have the original cleartext on stdout now. output = get_bytes_out(out) - self.assertEqual(b'Hello cleartext RSA users!', output) + self.assertEqual(b"Hello cleartext RSA users!", output) - @cleanup_files('encrypted.txt', 'cleartext.txt') + @cleanup_files("encrypted.txt", "cleartext.txt") def test_encrypt_decrypt_unhappy(self): - with open('cleartext.txt', 'wb') as outfile: - outfile.write(b'Hello cleartext RSA users!') + with open("cleartext.txt", "wb") as outfile: + outfile.write(b"Hello cleartext RSA users!") - with cli_args('-i', 'cleartext.txt', '--out=encrypted.txt', self.pub_fname): + with cli_args("-i", "cleartext.txt", "--out=encrypted.txt", self.pub_fname): with captured_output(): rsa.cli.encrypt() # Change a few bytes in the encrypted stream. - with open('encrypted.txt', 'r+b') as encfile: + with open("encrypted.txt", "r+b") as encfile: encfile.seek(40) - encfile.write(b'hahaha') + encfile.write(b"hahaha") - with cli_args('-i', 'encrypted.txt', self.priv_fname): + with cli_args("-i", "encrypted.txt", self.priv_fname): with captured_output() as (out, err): self.assertRaises(rsa.DecryptionError, rsa.cli.decrypt) @@ -234,52 +239,52 @@ class SignVerifyTest(AbstractCliTest): with captured_output(), cli_args(): self.assertExits(1, rsa.cli.sign) - @cleanup_files('signature.txt', 'cleartext.txt') + @cleanup_files("signature.txt", "cleartext.txt") def test_sign_verify(self): - with open('cleartext.txt', 'wb') as outfile: - outfile.write(b'Hello RSA users!') + with open("cleartext.txt", "wb") as outfile: + outfile.write(b"Hello RSA users!") - with cli_args('-i', 'cleartext.txt', '--out=signature.txt', self.priv_fname, 'SHA-256'): + with cli_args("-i", "cleartext.txt", "--out=signature.txt", self.priv_fname, "SHA-256"): with captured_output(): rsa.cli.sign() - with cli_args('-i', 'cleartext.txt', self.pub_fname, 'signature.txt'): + with cli_args("-i", "cleartext.txt", self.pub_fname, "signature.txt"): with captured_output() as (out, err): rsa.cli.verify() - self.assertFalse(b'Verification OK' in get_bytes_out(out)) + self.assertFalse(b"Verification OK" in get_bytes_out(out)) - @cleanup_files('signature.txt', 'cleartext.txt') + @cleanup_files("signature.txt", "cleartext.txt") def test_sign_verify_unhappy(self): - with open('cleartext.txt', 'wb') as outfile: - outfile.write(b'Hello RSA users!') + with open("cleartext.txt", "wb") as outfile: + outfile.write(b"Hello RSA users!") - with cli_args('-i', 'cleartext.txt', '--out=signature.txt', self.priv_fname, 'SHA-256'): + with cli_args("-i", "cleartext.txt", "--out=signature.txt", self.priv_fname, "SHA-256"): with captured_output(): rsa.cli.sign() # Change a few bytes in the cleartext file. - with open('cleartext.txt', 'r+b') as encfile: + with open("cleartext.txt", "r+b") as encfile: encfile.seek(6) - encfile.write(b'DSA') + encfile.write(b"DSA") - with cli_args('-i', 'cleartext.txt', self.pub_fname, 'signature.txt'): + with cli_args("-i", "cleartext.txt", self.pub_fname, "signature.txt"): with captured_output() as (out, err): - self.assertExits('Verification failed.', rsa.cli.verify) + self.assertExits("Verification failed.", rsa.cli.verify) class PrivatePublicTest(AbstractCliTest): """Test CLI command to convert a private to a public key.""" - @cleanup_files('test_private_to_public.pem') + @cleanup_files("test_private_to_public.pem") def test_private_to_public(self): - with cli_args('-i', self.priv_fname, '-o', 'test_private_to_public.pem'): + with cli_args("-i", self.priv_fname, "-o", "test_private_to_public.pem"): with captured_output(): rsa.util.private_to_public() # Check that the key is indeed valid. - with open('test_private_to_public.pem', 'rb') as pemfile: + with open("test_private_to_public.pem", "rb") as pemfile: key = rsa.PublicKey.load_pkcs1(pemfile.read()) self.assertEqual(self.priv_key.n, key.n) diff --git a/tests/test_common.py b/tests/test_common.py index 71b81d0..ac56bcd 100644 --- a/tests/test_common.py +++ b/tests/test_common.py @@ -21,8 +21,8 @@ from rsa.common import byte_size, bit_size, inverse class TestByte(unittest.TestCase): def test_values(self): - self.assertEqual(byte(0), b'\x00') - self.assertEqual(byte(255), b'\xff') + self.assertEqual(byte(0), b"\x00") + self.assertEqual(byte(255), b"\xff") def test_struct_error_when_out_of_bounds(self): self.assertRaises(struct.error, byte, 256) @@ -36,13 +36,13 @@ class TestByteSize(unittest.TestCase): self.assertEqual(byte_size(1 << 1024), 129) self.assertEqual(byte_size(255), 1) self.assertEqual(byte_size(256), 2) - self.assertEqual(byte_size(0xffff), 2) - self.assertEqual(byte_size(0xffffff), 3) - self.assertEqual(byte_size(0xffffffff), 4) - self.assertEqual(byte_size(0xffffffffff), 5) - self.assertEqual(byte_size(0xffffffffffff), 6) - self.assertEqual(byte_size(0xffffffffffffff), 7) - self.assertEqual(byte_size(0xffffffffffffffff), 8) + self.assertEqual(byte_size(0xFFFF), 2) + self.assertEqual(byte_size(0xFFFFFF), 3) + self.assertEqual(byte_size(0xFFFFFFFF), 4) + self.assertEqual(byte_size(0xFFFFFFFFFF), 5) + self.assertEqual(byte_size(0xFFFFFFFFFFFF), 6) + self.assertEqual(byte_size(0xFFFFFFFFFFFFFF), 7) + self.assertEqual(byte_size(0xFFFFFFFFFFFFFFFF), 8) def test_zero(self): self.assertEqual(byte_size(0), 1) diff --git a/tests/test_compat.py b/tests/test_compat.py index e74f046..9c65315 100644 --- a/tests/test_compat.py +++ b/tests/test_compat.py @@ -32,41 +32,41 @@ class TestByte(unittest.TestCase): self.assertRaises(struct.error, byte, -1) def test_byte_literal(self): - self.assertIsInstance(b'abc', bytes) + self.assertIsInstance(b"abc", bytes) class TestBytes(unittest.TestCase): """Tests for bytes objects.""" def setUp(self): - self.b1 = b'\xff\xff\xff\xff' - self.b2 = b'\x00\x00\x00\x00' - self.b3 = b'\xf0\xf0\xf0\xf0' - self.b4 = b'\x4d\x23\xca\xe2' - self.b5 = b'\x9b\x61\x3b\xdc' - self.b6 = b'\xff\xff' + self.b1 = b"\xff\xff\xff\xff" + self.b2 = b"\x00\x00\x00\x00" + self.b3 = b"\xf0\xf0\xf0\xf0" + self.b4 = b"\x4d\x23\xca\xe2" + self.b5 = b"\x9b\x61\x3b\xdc" + self.b6 = b"\xff\xff" self.byte_strings = (self.b1, self.b2, self.b3, self.b4, self.b5, self.b6) def test_xor_bytes(self): - self.assertEqual(xor_bytes(self.b1, self.b2), b'\xff\xff\xff\xff') - self.assertEqual(xor_bytes(self.b1, self.b3), b'\x0f\x0f\x0f\x0f') - self.assertEqual(xor_bytes(self.b1, self.b4), b'\xb2\xdc\x35\x1d') - self.assertEqual(xor_bytes(self.b1, self.b5), b'\x64\x9e\xc4\x23') - self.assertEqual(xor_bytes(self.b2, self.b3), b'\xf0\xf0\xf0\xf0') - self.assertEqual(xor_bytes(self.b2, self.b4), b'\x4d\x23\xca\xe2') - self.assertEqual(xor_bytes(self.b2, self.b5), b'\x9b\x61\x3b\xdc') - self.assertEqual(xor_bytes(self.b3, self.b4), b'\xbd\xd3\x3a\x12') - self.assertEqual(xor_bytes(self.b3, self.b5), b'\x6b\x91\xcb\x2c') - self.assertEqual(xor_bytes(self.b4, self.b5), b'\xd6\x42\xf1\x3e') + self.assertEqual(xor_bytes(self.b1, self.b2), b"\xff\xff\xff\xff") + self.assertEqual(xor_bytes(self.b1, self.b3), b"\x0f\x0f\x0f\x0f") + self.assertEqual(xor_bytes(self.b1, self.b4), b"\xb2\xdc\x35\x1d") + self.assertEqual(xor_bytes(self.b1, self.b5), b"\x64\x9e\xc4\x23") + self.assertEqual(xor_bytes(self.b2, self.b3), b"\xf0\xf0\xf0\xf0") + self.assertEqual(xor_bytes(self.b2, self.b4), b"\x4d\x23\xca\xe2") + self.assertEqual(xor_bytes(self.b2, self.b5), b"\x9b\x61\x3b\xdc") + self.assertEqual(xor_bytes(self.b3, self.b4), b"\xbd\xd3\x3a\x12") + self.assertEqual(xor_bytes(self.b3, self.b5), b"\x6b\x91\xcb\x2c") + self.assertEqual(xor_bytes(self.b4, self.b5), b"\xd6\x42\xf1\x3e") def test_xor_bytes_length(self): - self.assertEqual(xor_bytes(self.b1, self.b6), b'\x00\x00') - self.assertEqual(xor_bytes(self.b2, self.b6), b'\xff\xff') - self.assertEqual(xor_bytes(self.b3, self.b6), b'\x0f\x0f') - self.assertEqual(xor_bytes(self.b4, self.b6), b'\xb2\xdc') - self.assertEqual(xor_bytes(self.b5, self.b6), b'\x64\x9e') - self.assertEqual(xor_bytes(self.b6, b''), b'') + self.assertEqual(xor_bytes(self.b1, self.b6), b"\x00\x00") + self.assertEqual(xor_bytes(self.b2, self.b6), b"\xff\xff") + self.assertEqual(xor_bytes(self.b3, self.b6), b"\x0f\x0f") + self.assertEqual(xor_bytes(self.b4, self.b6), b"\xb2\xdc") + self.assertEqual(xor_bytes(self.b5, self.b6), b"\x64\x9e") + self.assertEqual(xor_bytes(self.b6, b""), b"") def test_xor_bytes_commutative(self): for first in self.byte_strings: diff --git a/tests/test_load_save_keys.py b/tests/test_load_save_keys.py index d881d20..3e90999 100644 --- a/tests/test_load_save_keys.py +++ b/tests/test_load_save_keys.py @@ -23,51 +23,67 @@ from unittest import mock import rsa.key -B64PRIV_DER = b'MC4CAQACBQDeKYlRAgMBAAECBQDHn4npAgMA/icCAwDfxwIDANcXAgInbwIDAMZt' +B64PRIV_DER = b"MC4CAQACBQDeKYlRAgMBAAECBQDHn4npAgMA/icCAwDfxwIDANcXAgInbwIDAMZt" PRIVATE_DER = base64.standard_b64decode(B64PRIV_DER) -B64PUB_DER = b'MAwCBQDeKYlRAgMBAAE=' +B64PUB_DER = b"MAwCBQDeKYlRAgMBAAE=" PUBLIC_DER = base64.standard_b64decode(B64PUB_DER) -PRIVATE_PEM = b'''\ +PRIVATE_PEM = ( + b"""\ -----BEGIN CONFUSING STUFF----- Cruft before the key -----BEGIN RSA PRIVATE KEY----- Comment: something blah -''' + B64PRIV_DER + b''' +""" + + B64PRIV_DER + + b""" -----END RSA PRIVATE KEY----- Stuff after the key -----END CONFUSING STUFF----- -''' +""" +) -CLEAN_PRIVATE_PEM = b'''\ +CLEAN_PRIVATE_PEM = ( + b"""\ -----BEGIN RSA PRIVATE KEY----- -''' + B64PRIV_DER + b''' +""" + + B64PRIV_DER + + b""" -----END RSA PRIVATE KEY----- -''' +""" +) -PUBLIC_PEM = b'''\ +PUBLIC_PEM = ( + b"""\ -----BEGIN CONFUSING STUFF----- Cruft before the key -----BEGIN RSA PUBLIC KEY----- Comment: something blah -''' + B64PUB_DER + b''' +""" + + B64PUB_DER + + b""" -----END RSA PUBLIC KEY----- Stuff after the key -----END CONFUSING STUFF----- -''' +""" +) -CLEAN_PUBLIC_PEM = b'''\ +CLEAN_PUBLIC_PEM = ( + b"""\ -----BEGIN RSA PUBLIC KEY----- -''' + B64PUB_DER + b''' +""" + + B64PUB_DER + + b""" -----END RSA PUBLIC KEY----- -''' +""" +) class DerTest(unittest.TestCase): @@ -76,7 +92,7 @@ class DerTest(unittest.TestCase): def test_load_private_key(self): """Test loading private DER keys.""" - key = rsa.key.PrivateKey.load_pkcs1(PRIVATE_DER, 'DER') + key = rsa.key.PrivateKey.load_pkcs1(PRIVATE_DER, "DER") expected = rsa.key.PrivateKey(3727264081, 65537, 3349121513, 65063, 57287) self.assertEqual(expected, key) @@ -84,7 +100,7 @@ class DerTest(unittest.TestCase): self.assertEqual(key.exp2, 10095) self.assertEqual(key.coef, 50797) - @mock.patch('pyasn1.codec.der.decoder.decode') + @mock.patch("pyasn1.codec.der.decoder.decode") def test_load_malformed_private_key(self, der_decode): """Test loading malformed private DER keys.""" @@ -96,18 +112,18 @@ class DerTest(unittest.TestCase): with warnings.catch_warnings(record=True) as w: # Always print warnings - warnings.simplefilter('always') + warnings.simplefilter("always") # Load 3 keys for _ in range(3): - key = rsa.key.PrivateKey.load_pkcs1(PRIVATE_DER, 'DER') + key = rsa.key.PrivateKey.load_pkcs1(PRIVATE_DER, "DER") # Check that 3 warnings were generated. self.assertEqual(3, len(w)) for warning in w: self.assertTrue(issubclass(warning.category, UserWarning)) - self.assertIn('malformed', str(warning.message)) + self.assertIn("malformed", str(warning.message)) # Check that we are creating the key with correct values self.assertEqual(key.exp1, 55063) @@ -118,7 +134,7 @@ class DerTest(unittest.TestCase): """Test saving private DER keys.""" key = rsa.key.PrivateKey(3727264081, 65537, 3349121513, 65063, 57287) - der = key.save_pkcs1('DER') + der = key.save_pkcs1("DER") self.assertIsInstance(der, bytes) self.assertEqual(PRIVATE_DER, der) @@ -126,7 +142,7 @@ class DerTest(unittest.TestCase): def test_load_public_key(self): """Test loading public DER keys.""" - key = rsa.key.PublicKey.load_pkcs1(PUBLIC_DER, 'DER') + key = rsa.key.PublicKey.load_pkcs1(PUBLIC_DER, "DER") expected = rsa.key.PublicKey(3727264081, 65537) self.assertEqual(expected, key) @@ -135,7 +151,7 @@ class DerTest(unittest.TestCase): """Test saving public DER keys.""" key = rsa.key.PublicKey(3727264081, 65537) - der = key.save_pkcs1('DER') + der = key.save_pkcs1("DER") self.assertIsInstance(der, bytes) self.assertEqual(PUBLIC_DER, der) @@ -147,7 +163,7 @@ class PemTest(unittest.TestCase): def test_load_private_key(self): """Test loading private PEM files.""" - key = rsa.key.PrivateKey.load_pkcs1(PRIVATE_PEM, 'PEM') + key = rsa.key.PrivateKey.load_pkcs1(PRIVATE_PEM, "PEM") expected = rsa.key.PrivateKey(3727264081, 65537, 3349121513, 65063, 57287) self.assertEqual(expected, key) @@ -159,7 +175,7 @@ class PemTest(unittest.TestCase): """Test saving private PEM files.""" key = rsa.key.PrivateKey(3727264081, 65537, 3349121513, 65063, 57287) - pem = key.save_pkcs1('PEM') + pem = key.save_pkcs1("PEM") self.assertIsInstance(pem, bytes) self.assertEqual(CLEAN_PRIVATE_PEM, pem) @@ -167,7 +183,7 @@ class PemTest(unittest.TestCase): def test_load_public_key(self): """Test loading public PEM files.""" - key = rsa.key.PublicKey.load_pkcs1(PUBLIC_PEM, 'PEM') + key = rsa.key.PublicKey.load_pkcs1(PUBLIC_PEM, "PEM") expected = rsa.key.PublicKey(3727264081, 65537) self.assertEqual(expected, key) @@ -176,7 +192,7 @@ class PemTest(unittest.TestCase): """Test saving public PEM files.""" key = rsa.key.PublicKey(3727264081, 65537) - pem = key.save_pkcs1('PEM') + pem = key.save_pkcs1("PEM") self.assertIsInstance(pem, bytes) self.assertEqual(CLEAN_PUBLIC_PEM, pem) @@ -184,8 +200,8 @@ class PemTest(unittest.TestCase): def test_load_from_disk(self): """Test loading a PEM file from disk.""" - fname = os.path.join(os.path.dirname(__file__), 'private.pem') - with open(fname, mode='rb') as privatefile: + fname = os.path.join(os.path.dirname(__file__), "private.pem") + with open(fname, mode="rb") as privatefile: keydata = privatefile.read() privkey = rsa.key.PrivateKey.load_pkcs1(keydata) diff --git a/tests/test_mypy.py b/tests/test_mypy.py index b13cdcc..8cc0d59 100644 --- a/tests/test_mypy.py +++ b/tests/test_mypy.py @@ -4,16 +4,16 @@ import unittest import mypy.api -test_modules = ['rsa', 'tests'] +test_modules = ["rsa", "tests"] class MypyRunnerTest(unittest.TestCase): def test_run_mypy(self): proj_root = pathlib.Path(__file__).parent.parent args = [ - '--incremental', - '--ignore-missing-imports', - f'--python-version={sys.version_info.major}.{sys.version_info.minor}' + "--incremental", + "--ignore-missing-imports", + f"--python-version={sys.version_info.major}.{sys.version_info.minor}", ] + [str(proj_root / dirname) for dirname in test_modules] result = mypy.api.run(args) @@ -26,6 +26,6 @@ class MypyRunnerTest(unittest.TestCase): if stdout: messages.append(stdout) if status: - messages.append('Mypy failed with status %d' % status) - if messages and not all('Success' in message for message in messages): - self.fail('\n'.join(['Mypy errors:'] + messages)) + messages.append("Mypy failed with status %d" % status) + if messages and not all("Success" in message for message in messages): + self.fail("\n".join(["Mypy errors:"] + messages)) diff --git a/tests/test_pem.py b/tests/test_pem.py index dd03cca..7440431 100644 --- a/tests/test_pem.py +++ b/tests/test_pem.py @@ -19,14 +19,14 @@ from rsa.pem import _markers import rsa.key # 512-bit key. Too small for practical purposes, but good enough for testing with. -public_key_pem = ''' +public_key_pem = """ -----BEGIN PUBLIC KEY----- MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAKH0aYP9ZFuctlPnXhEyHjgc8ltKKx9M 0c+h4sKMXwjhjbQAZdtWIw8RRghpUJnKj+6bN2XzZDazyULxgPhtax0CAwEAAQ== -----END PUBLIC KEY----- -''' +""" -private_key_pem = ''' +private_key_pem = """ -----BEGIN RSA PRIVATE KEY----- MIIBOwIBAAJBAKH0aYP9ZFuctlPnXhEyHjgc8ltKKx9M0c+h4sKMXwjhjbQAZdtW Iw8RRghpUJnKj+6bN2XzZDazyULxgPhtax0CAwEAAQJADwR36EpNzQTqDzusCFIq @@ -36,7 +36,7 @@ F8p1J98BEbtjU2mEZIVCMn6vQuhWdl8CIDRL4IJl4eGKlB0QP0JJF1wpeGO/R76l DaPF5cMM7k3NAiEAss28m/ck9BWBfFVdNjx/vsdFZkx2O9AX9EJWoBSnSgECIQCa +sVQMUVJFGsdE/31C7wCIbE3IpB7ziABZ7mN+V3Dhg== -----END RSA PRIVATE KEY----- -''' +""" # Private key components prime1 = 96275860229939261876671084930484419185939191875438854026071315955024109172739 @@ -45,9 +45,10 @@ prime2 = 88103681619592083641803383393198542599284510949756076218404908654323473 class TestMarkers(unittest.TestCase): def test_values(self): - self.assertEqual(_markers('RSA PRIVATE KEY'), - (b'-----BEGIN RSA PRIVATE KEY-----', - b'-----END RSA PRIVATE KEY-----')) + self.assertEqual( + _markers("RSA PRIVATE KEY"), + (b"-----BEGIN RSA PRIVATE KEY-----", b"-----END RSA PRIVATE KEY-----"), + ) class TestBytesAndStrings(unittest.TestCase): @@ -58,7 +59,7 @@ class TestBytesAndStrings(unittest.TestCase): self.assertEqual(prime1 * prime2, key.n) def test_bytes_public(self): - key = rsa.key.PublicKey.load_pkcs1_openssl_pem(public_key_pem.encode('ascii')) + key = rsa.key.PublicKey.load_pkcs1_openssl_pem(public_key_pem.encode("ascii")) self.assertEqual(prime1 * prime2, key.n) def test_unicode_private(self): @@ -66,7 +67,7 @@ class TestBytesAndStrings(unittest.TestCase): self.assertEqual(prime1 * prime2, key.n) def test_bytes_private(self): - key = rsa.key.PrivateKey.load_pkcs1(private_key_pem.encode('ascii')) + key = rsa.key.PrivateKey.load_pkcs1(private_key_pem.encode("ascii")) self.assertEqual(prime1, key.p) self.assertEqual(prime2, key.q) @@ -76,24 +77,24 @@ class TestByteOutput(unittest.TestCase): def test_bytes_public(self): key = rsa.key.PublicKey.load_pkcs1_openssl_pem(public_key_pem) - self.assertIsInstance(key.save_pkcs1(format='DER'), bytes) - self.assertIsInstance(key.save_pkcs1(format='PEM'), bytes) + self.assertIsInstance(key.save_pkcs1(format="DER"), bytes) + self.assertIsInstance(key.save_pkcs1(format="PEM"), bytes) def test_bytes_private(self): key = rsa.key.PrivateKey.load_pkcs1(private_key_pem) - self.assertIsInstance(key.save_pkcs1(format='DER'), bytes) - self.assertIsInstance(key.save_pkcs1(format='PEM'), bytes) + self.assertIsInstance(key.save_pkcs1(format="DER"), bytes) + self.assertIsInstance(key.save_pkcs1(format="PEM"), bytes) class TestByteInput(unittest.TestCase): """Tests that PEM and DER can be loaded from bytes.""" def test_bytes_public(self): - key = rsa.key.PublicKey.load_pkcs1_openssl_pem(public_key_pem.encode('ascii')) - self.assertIsInstance(key.save_pkcs1(format='DER'), bytes) - self.assertIsInstance(key.save_pkcs1(format='PEM'), bytes) + key = rsa.key.PublicKey.load_pkcs1_openssl_pem(public_key_pem.encode("ascii")) + self.assertIsInstance(key.save_pkcs1(format="DER"), bytes) + self.assertIsInstance(key.save_pkcs1(format="PEM"), bytes) def test_bytes_private(self): - key = rsa.key.PrivateKey.load_pkcs1(private_key_pem.encode('ascii')) - self.assertIsInstance(key.save_pkcs1(format='DER'), bytes) - self.assertIsInstance(key.save_pkcs1(format='PEM'), bytes) + key = rsa.key.PrivateKey.load_pkcs1(private_key_pem.encode("ascii")) + self.assertIsInstance(key.save_pkcs1(format="DER"), bytes) + self.assertIsInstance(key.save_pkcs1(format="PEM"), bytes) diff --git a/tests/test_pkcs1.py b/tests/test_pkcs1.py index 272e2bc..f2d4957 100644 --- a/tests/test_pkcs1.py +++ b/tests/test_pkcs1.py @@ -28,7 +28,7 @@ class BinaryTest(unittest.TestCase): (self.pub, self.priv) = rsa.newkeys(256) def test_enc_dec(self): - message = struct.pack('>IIII', 0, 0, 0, 1) + message = struct.pack(">IIII", 0, 0, 0, 1) print("\n\tMessage: %r" % message) encrypted = pkcs1.encrypt(message, self.pub) @@ -40,7 +40,7 @@ class BinaryTest(unittest.TestCase): self.assertEqual(message, decrypted) def test_decoding_failure(self): - message = struct.pack('>IIII', 0, 0, 0, 1) + message = struct.pack(">IIII", 0, 0, 0, 1) encrypted = pkcs1.encrypt(message, self.pub) # Alter the encrypted stream @@ -50,15 +50,14 @@ class BinaryTest(unittest.TestCase): altered_a = (a + 1) % 256 encrypted = encrypted[:5] + byte(altered_a) + encrypted[6:] - self.assertRaises(pkcs1.DecryptionError, pkcs1.decrypt, encrypted, - self.priv) + self.assertRaises(pkcs1.DecryptionError, pkcs1.decrypt, encrypted, self.priv) def test_randomness(self): """Encrypting the same message twice should result in different cryptos. """ - message = struct.pack('>IIII', 0, 0, 0, 1) + message = struct.pack(">IIII", 0, 0, 0, 1) encrypted1 = pkcs1.encrypt(message, self.pub) encrypted2 = pkcs1.encrypt(message, self.pub) @@ -70,7 +69,8 @@ class ExtraZeroesTest(unittest.TestCase): # Key, cyphertext, and plaintext taken from https://github.com/sybrenstuvel/python-rsa/issues/146 self.private_key = rsa.PrivateKey.load_pkcs1( "-----BEGIN RSA PRIVATE KEY-----\nMIIEowIBAAKCAQEAs1EKK81M5kTFtZSuUFnhKy8FS2WNXaWVmi/fGHG4CLw98+Yo\n0nkuUarVwSS0O9pFPcpc3kvPKOe9Tv+6DLS3Qru21aATy2PRqjqJ4CYn71OYtSwM\n/ZfSCKvrjXybzgu+sBmobdtYm+sppbdL+GEHXGd8gdQw8DDCZSR6+dPJFAzLZTCd\nB+Ctwe/RXPF+ewVdfaOGjkZIzDoYDw7n+OHnsYCYozkbTOcWHpjVevipR+IBpGPi\n1rvKgFnlcG6d/tj0hWRl/6cS7RqhjoiNEtxqoJzpXs/Kg8xbCxXbCchkf11STA8u\ndiCjQWuWI8rcDwl69XMmHJjIQAqhKvOOQ8rYTQIDAQABAoIBABpQLQ7qbHtp4h1Y\nORAfcFRW7Q74UvtH/iEHH1TF8zyM6wZsYtcn4y0mxYE3Mp+J0xlTJbeVJkwZXYVH\nL3UH29CWHSlR+TWiazTwrCTRVJDhEoqbcTiRW8fb+o/jljVxMcVDrpyYUHNo2c6w\njBxhmKPtp66hhaDpds1Cwi0A8APZ8Z2W6kya/L/hRBzMgCz7Bon1nYBMak5PQEwV\nF0dF7Wy4vIjvCzO6DSqA415DvJDzUAUucgFudbANNXo4HJwNRnBpymYIh8mHdmNJ\n/MQ0YLSqUWvOB57dh7oWQwe3UsJ37ZUorTugvxh3NJ7Tt5ZqbCQBEECb9ND63gxo\n/a3YR/0CgYEA7BJc834xCi/0YmO5suBinWOQAF7IiRPU+3G9TdhWEkSYquupg9e6\nK9lC5k0iP+t6I69NYF7+6mvXDTmv6Z01o6oV50oXaHeAk74O3UqNCbLe9tybZ/+F\ndkYlwuGSNttMQBzjCiVy0+y0+Wm3rRnFIsAtd0RlZ24aN3bFTWJINIsCgYEAwnQq\nvNmJe9SwtnH5c/yCqPhKv1cF/4jdQZSGI6/p3KYNxlQzkHZ/6uvrU5V27ov6YbX8\nvKlKfO91oJFQxUD6lpTdgAStI3GMiJBJIZNpyZ9EWNSvwUj28H34cySpbZz3s4Xd\nhiJBShgy+fKURvBQwtWmQHZJ3EGrcOI7PcwiyYcCgYEAlql5jSUCY0ALtidzQogW\nJ+B87N+RGHsBuJ/0cxQYinwg+ySAAVbSyF1WZujfbO/5+YBN362A/1dn3lbswCnH\nK/bHF9+fZNqvwprPnceQj5oK1n4g6JSZNsy6GNAhosT+uwQ0misgR8SQE4W25dDG\nkdEYsz+BgCsyrCcu8J5C+tUCgYAFVPQbC4f2ikVyKzvgz0qx4WUDTBqRACq48p6e\n+eLatv7nskVbr7QgN+nS9+Uz80ihR0Ev1yCAvnwmM/XYAskcOea87OPmdeWZlQM8\nVXNwINrZ6LMNBLgorfuTBK1UoRo1pPUHCYdqxbEYI2unak18mikd2WB7Fp3h0YI4\nVpGZnwKBgBxkAYnZv+jGI4MyEKdsQgxvROXXYOJZkWzsKuKxVkVpYP2V4nR2YMOJ\nViJQ8FUEnPq35cMDlUk4SnoqrrHIJNOvcJSCqM+bWHAioAsfByLbUPM8sm3CDdIk\nXVJl32HuKYPJOMIWfc7hIfxLRHnCN+coz2M6tgqMDs0E/OfjuqVZ\n-----END RSA PRIVATE KEY-----", - format='PEM') + format="PEM", + ) self.cyphertext = bytes.fromhex( "4501b4d669e01b9ef2dc800aa1b06d49196f5a09fe8fbcd037323c60eaf027bfb98432be4e4a26c567ffec718bcbea977dd26812fa071c33808b4d5ebb742d9879806094b6fbeea63d25ea3141733b60e31c6912106e1b758a7fe0014f075193faa8b4622bfd5d3013f0a32190a95de61a3604711bc62945f95a6522bd4dfed0a994ef185b28c281f7b5e4c8ed41176d12d9fc1b837e6a0111d0132d08a6d6f0580de0c9eed8ed105531799482d1e466c68c23b0c222af7fc12ac279bc4ff57e7b4586d209371b38c4c1035edd418dc5f960441cb21ea2bedbfea86de0d7861e81021b650a1de51002c315f1e7c12debe4dcebf790caaa54a2f26b149cf9e77d" ) @@ -98,89 +98,88 @@ class SignatureTest(unittest.TestCase): def test_sign_verify(self): """Test happy flow of sign and verify""" - message = b'je moeder' - signature = pkcs1.sign(message, self.priv, 'SHA-256') - self.assertEqual('SHA-256', pkcs1.verify(message, signature, self.pub)) - + message = b"je moeder" + signature = pkcs1.sign(message, self.priv, "SHA-256") + self.assertEqual("SHA-256", pkcs1.verify(message, signature, self.pub)) @unittest.skipIf(sys.version_info < (3, 6), "SHA3 requires Python 3.6+") def test_sign_verify_sha3(self): """Test happy flow of sign and verify with SHA3-256""" - message = b'je moeder' - signature = pkcs1.sign(message, self.priv, 'SHA3-256') - self.assertEqual('SHA3-256', pkcs1.verify(message, signature, self.pub)) + message = b"je moeder" + signature = pkcs1.sign(message, self.priv, "SHA3-256") + self.assertEqual("SHA3-256", pkcs1.verify(message, signature, self.pub)) def test_find_signature_hash(self): """Test happy flow of sign and find_signature_hash""" - message = b'je moeder' - signature = pkcs1.sign(message, self.priv, 'SHA-256') + message = b"je moeder" + signature = pkcs1.sign(message, self.priv, "SHA-256") - self.assertEqual('SHA-256', pkcs1.find_signature_hash(signature, self.pub)) + self.assertEqual("SHA-256", pkcs1.find_signature_hash(signature, self.pub)) def test_alter_message(self): """Altering the message should let the verification fail.""" - signature = pkcs1.sign(b'je moeder', self.priv, 'SHA-256') - self.assertRaises(pkcs1.VerificationError, pkcs1.verify, - b'mijn moeder', signature, self.pub) + signature = pkcs1.sign(b"je moeder", self.priv, "SHA-256") + self.assertRaises( + pkcs1.VerificationError, pkcs1.verify, b"mijn moeder", signature, self.pub + ) def test_sign_different_key(self): """Signing with another key should let the verification fail.""" (otherpub, _) = rsa.newkeys(512) - message = b'je moeder' - signature = pkcs1.sign(message, self.priv, 'SHA-256') - self.assertRaises(pkcs1.VerificationError, pkcs1.verify, - message, signature, otherpub) + message = b"je moeder" + signature = pkcs1.sign(message, self.priv, "SHA-256") + self.assertRaises(pkcs1.VerificationError, pkcs1.verify, message, signature, otherpub) def test_multiple_signings(self): """Signing the same message twice should return the same signatures.""" - message = struct.pack('>IIII', 0, 0, 0, 1) - signature1 = pkcs1.sign(message, self.priv, 'SHA-1') - signature2 = pkcs1.sign(message, self.priv, 'SHA-1') + message = struct.pack(">IIII", 0, 0, 0, 1) + signature1 = pkcs1.sign(message, self.priv, "SHA-1") + signature2 = pkcs1.sign(message, self.priv, "SHA-1") self.assertEqual(signature1, signature2) def test_split_hash_sign(self): """Hashing and then signing should match with directly signing the message. """ - message = b'je moeder' - msg_hash = pkcs1.compute_hash(message, 'SHA-256') - signature1 = pkcs1.sign_hash(msg_hash, self.priv, 'SHA-256') + message = b"je moeder" + msg_hash = pkcs1.compute_hash(message, "SHA-256") + signature1 = pkcs1.sign_hash(msg_hash, self.priv, "SHA-256") # Calculate the signature using the unified method - signature2 = pkcs1.sign(message, self.priv, 'SHA-256') + signature2 = pkcs1.sign(message, self.priv, "SHA-256") self.assertEqual(signature1, signature2) def test_hash_sign_verify(self): """Test happy flow of hash, sign, and verify""" - message = b'je moeder' - msg_hash = pkcs1.compute_hash(message, 'SHA-224') - signature = pkcs1.sign_hash(msg_hash, self.priv, 'SHA-224') + message = b"je moeder" + msg_hash = pkcs1.compute_hash(message, "SHA-224") + signature = pkcs1.sign_hash(msg_hash, self.priv, "SHA-224") self.assertTrue(pkcs1.verify(message, signature, self.pub)) def test_prepend_zeroes(self): """Prepending the signature with zeroes should be detected.""" - message = b'je moeder' - signature = pkcs1.sign(message, self.priv, 'SHA-256') - signature = bytes.fromhex('0000') + signature + message = b"je moeder" + signature = pkcs1.sign(message, self.priv, "SHA-256") + signature = bytes.fromhex("0000") + signature with self.assertRaises(rsa.VerificationError): pkcs1.verify(message, signature, self.pub) def test_apppend_zeroes(self): """Apppending the signature with zeroes should be detected.""" - message = b'je moeder' - signature = pkcs1.sign(message, self.priv, 'SHA-256') - signature = signature + bytes.fromhex('0000') + message = b"je moeder" + signature = pkcs1.sign(message, self.priv, "SHA-256") + signature = signature + bytes.fromhex("0000") with self.assertRaises(rsa.VerificationError): pkcs1.verify(message, signature, self.pub) @@ -191,16 +190,18 @@ class PaddingSizeTest(unittest.TestCase): # Construct key that will be small enough to need only 7 bytes of padding. # This key is 168 bit long, and was generated with rsa.newkeys(nbits=168). - self.private_key = rsa.PrivateKey.load_pkcs1(b''' + self.private_key = rsa.PrivateKey.load_pkcs1( + b""" -----BEGIN RSA PRIVATE KEY----- MHkCAQACFgCIGbbNSkIRLtprxka9NgOf5UxgxCMCAwEAAQIVQqymO0gHubdEVS68 CdCiWmOJxVfRAgwBQM+e1JJwMKmxSF0CCmya6CFxO8Evdn8CDACMM3AlVC4FhlN8 3QIKC9cjoam/swMirwIMAR7Br9tdouoH7jAE -----END RSA PRIVATE KEY----- - ''') + """ + ) self.public_key = rsa.PublicKey(n=self.private_key.n, e=self.private_key.e) - cyphertext = self.encrypt_with_short_padding(b'op je hoofd') + cyphertext = self.encrypt_with_short_padding(b"op je hoofd") with self.assertRaises(rsa.DecryptionError): rsa.decrypt(cyphertext, self.private_key) @@ -209,7 +210,7 @@ CdCiWmOJxVfRAgwBQM+e1JJwMKmxSF0CCmya6CFxO8Evdn8CDACMM3AlVC4FhlN8 keylength = rsa.common.byte_size(self.public_key.n) # The word 'padding' has 7 letters, so is one byte short of a valid padding length. - padded = b'\x00\x02padding\x00' + message + padded = b"\x00\x02padding\x00" + message payload = rsa.transform.bytes2int(padded) encrypted_value = rsa.core.encrypt_int(payload, self.public_key.e, self.public_key.n) diff --git a/tests/test_pkcs1_v2.py b/tests/test_pkcs1_v2.py index bba525e..ead1393 100644 --- a/tests/test_pkcs1_v2.py +++ b/tests/test_pkcs1_v2.py @@ -26,38 +26,37 @@ from rsa import pkcs1_v2 class MGFTest(unittest.TestCase): def test_oaep_int_db_mask(self): seed = ( - b'\xaa\xfd\x12\xf6\x59\xca\xe6\x34\x89\xb4\x79\xe5\x07\x6d\xde\xc2' - b'\xf0\x6c\xb5\x8f' + b"\xaa\xfd\x12\xf6\x59\xca\xe6\x34\x89\xb4\x79\xe5\x07\x6d\xde\xc2" b"\xf0\x6c\xb5\x8f" ) db = ( - b'\xda\x39\xa3\xee\x5e\x6b\x4b\x0d\x32\x55\xbf\xef\x95\x60\x18\x90' - b'\xaf\xd8\x07\x09\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' - b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' - b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' - b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' - b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\xd4\x36\xe9\x95\x69' - b'\xfd\x32\xa7\xc8\xa0\x5b\xbc\x90\xd3\x2c\x49' + b"\xda\x39\xa3\xee\x5e\x6b\x4b\x0d\x32\x55\xbf\xef\x95\x60\x18\x90" + b"\xaf\xd8\x07\x09\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\xd4\x36\xe9\x95\x69" + b"\xfd\x32\xa7\xc8\xa0\x5b\xbc\x90\xd3\x2c\x49" ) masked_db = ( - b'\xdc\xd8\x7d\x5c\x68\xf1\xee\xa8\xf5\x52\x67\xc3\x1b\x2e\x8b\xb4' - b'\x25\x1f\x84\xd7\xe0\xb2\xc0\x46\x26\xf5\xaf\xf9\x3e\xdc\xfb\x25' - b'\xc9\xc2\xb3\xff\x8a\xe1\x0e\x83\x9a\x2d\xdb\x4c\xdc\xfe\x4f\xf4' - b'\x77\x28\xb4\xa1\xb7\xc1\x36\x2b\xaa\xd2\x9a\xb4\x8d\x28\x69\xd5' - b'\x02\x41\x21\x43\x58\x11\x59\x1b\xe3\x92\xf9\x82\xfb\x3e\x87\xd0' - b'\x95\xae\xb4\x04\x48\xdb\x97\x2f\x3a\xc1\x4f\x7b\xc2\x75\x19\x52' - b'\x81\xce\x32\xd2\xf1\xb7\x6d\x4d\x35\x3e\x2d' + b"\xdc\xd8\x7d\x5c\x68\xf1\xee\xa8\xf5\x52\x67\xc3\x1b\x2e\x8b\xb4" + b"\x25\x1f\x84\xd7\xe0\xb2\xc0\x46\x26\xf5\xaf\xf9\x3e\xdc\xfb\x25" + b"\xc9\xc2\xb3\xff\x8a\xe1\x0e\x83\x9a\x2d\xdb\x4c\xdc\xfe\x4f\xf4" + b"\x77\x28\xb4\xa1\xb7\xc1\x36\x2b\xaa\xd2\x9a\xb4\x8d\x28\x69\xd5" + b"\x02\x41\x21\x43\x58\x11\x59\x1b\xe3\x92\xf9\x82\xfb\x3e\x87\xd0" + b"\x95\xae\xb4\x04\x48\xdb\x97\x2f\x3a\xc1\x4f\x7b\xc2\x75\x19\x52" + b"\x81\xce\x32\xd2\xf1\xb7\x6d\x4d\x35\x3e\x2d" ) # dbMask = MGF(seed, length(DB)) db_mask = pkcs1_v2.mgf1(seed, length=len(db)) expected_db_mask = ( - b'\x06\xe1\xde\xb2\x36\x9a\xa5\xa5\xc7\x07\xd8\x2c\x8e\x4e\x93\x24' - b'\x8a\xc7\x83\xde\xe0\xb2\xc0\x46\x26\xf5\xaf\xf9\x3e\xdc\xfb\x25' - b'\xc9\xc2\xb3\xff\x8a\xe1\x0e\x83\x9a\x2d\xdb\x4c\xdc\xfe\x4f\xf4' - b'\x77\x28\xb4\xa1\xb7\xc1\x36\x2b\xaa\xd2\x9a\xb4\x8d\x28\x69\xd5' - b'\x02\x41\x21\x43\x58\x11\x59\x1b\xe3\x92\xf9\x82\xfb\x3e\x87\xd0' - b'\x95\xae\xb4\x04\x48\xdb\x97\x2f\x3a\xc1\x4e\xaf\xf4\x9c\x8c\x3b' - b'\x7c\xfc\x95\x1a\x51\xec\xd1\xdd\xe6\x12\x64' + b"\x06\xe1\xde\xb2\x36\x9a\xa5\xa5\xc7\x07\xd8\x2c\x8e\x4e\x93\x24" + b"\x8a\xc7\x83\xde\xe0\xb2\xc0\x46\x26\xf5\xaf\xf9\x3e\xdc\xfb\x25" + b"\xc9\xc2\xb3\xff\x8a\xe1\x0e\x83\x9a\x2d\xdb\x4c\xdc\xfe\x4f\xf4" + b"\x77\x28\xb4\xa1\xb7\xc1\x36\x2b\xaa\xd2\x9a\xb4\x8d\x28\x69\xd5" + b"\x02\x41\x21\x43\x58\x11\x59\x1b\xe3\x92\xf9\x82\xfb\x3e\x87\xd0" + b"\x95\xae\xb4\x04\x48\xdb\x97\x2f\x3a\xc1\x4e\xaf\xf4\x9c\x8c\x3b" + b"\x7c\xfc\x95\x1a\x51\xec\xd1\xdd\xe6\x12\x64" ) self.assertEqual(db_mask, expected_db_mask) @@ -65,8 +64,7 @@ class MGFTest(unittest.TestCase): # seedMask = MGF(maskedDB, length(seed)) seed_mask = pkcs1_v2.mgf1(masked_db, length=len(seed)) expected_seed_mask = ( - b'\x41\x87\x0b\x5a\xb0\x29\xe6\x57\xd9\x57\x50\xb5\x4c\x28\x3c\x08' - b'\x72\x5d\xbe\xa9' + b"\x41\x87\x0b\x5a\xb0\x29\xe6\x57\xd9\x57\x50\xb5\x4c\x28\x3c\x08" b"\x72\x5d\xbe\xa9" ) self.assertEqual(seed_mask, expected_seed_mask) @@ -74,8 +72,8 @@ class MGFTest(unittest.TestCase): def test_invalid_hasher(self): """Tests an invalid hasher generates an exception""" with self.assertRaises(ValueError): - pkcs1_v2.mgf1(b'\x06\xe1\xde\xb2', length=8, hasher='SHA2') + pkcs1_v2.mgf1(b"\x06\xe1\xde\xb2", length=8, hasher="SHA2") def test_invalid_length(self): with self.assertRaises(OverflowError): - pkcs1_v2.mgf1(b'\x06\xe1\xde\xb2', length=2**50) + pkcs1_v2.mgf1(b"\x06\xe1\xde\xb2", length=2 ** 50) diff --git a/tests/test_prime.py b/tests/test_prime.py index 5577f67..42d8af1 100644 --- a/tests/test_prime.py +++ b/tests/test_prime.py @@ -35,7 +35,7 @@ class PrimeTest(unittest.TestCase): # Test some slightly larger numbers self.assertEqual( [907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997], - [x for x in range(901, 1000) if rsa.prime.is_prime(x)] + [x for x in range(901, 1000) if rsa.prime.is_prime(x)], ) # Test around the 50th millionth known prime. @@ -62,13 +62,23 @@ class PrimeTest(unittest.TestCase): self.assertEqual([], randints) # 'Exit inner loop and continue with next witness' - randints.extend([ - 2119139098, # causes 'Exit inner loop and continue with next witness' - # the next witnesses for the above case: - 3051067716, 3603501763, 3230895847, 3687808133, 3760099987, 4026931495, 3022471882, - ]) - self.assertEqual(True, rsa.prime.miller_rabin_primality_testing(2211417913, - len(randints))) + randints.extend( + [ + 2119139098, # causes 'Exit inner loop and continue with next witness' + # the next witnesses for the above case: + 3051067716, + 3603501763, + 3230895847, + 3687808133, + 3760099987, + 4026931495, + 3022471882, + ] + ) + self.assertEqual( + True, + rsa.prime.miller_rabin_primality_testing(2211417913, len(randints)), + ) self.assertEqual([], randints) finally: rsa.randnum.randint = orig_randint @@ -84,22 +94,38 @@ class PrimeTest(unittest.TestCase): # List of known Mersenne exponents. known_mersenne_exponents = [ - 2, 3, 5, 7, 13, 17, 19, 31, 61, 89, 107, 127, 521, 607, 1279, - 2203, 2281, 4423, + 2, + 3, + 5, + 7, + 13, + 17, + 19, + 31, + 61, + 89, + 107, + 127, + 521, + 607, + 1279, + 2203, + 2281, + 4423, ] # Test Mersenne primes. for exp in known_mersenne_exponents: - self.assertTrue(rsa.prime.is_prime(2**exp - 1)) + self.assertTrue(rsa.prime.is_prime(2 ** exp - 1)) def test_get_primality_testing_rounds(self): """Test round calculation for primality testing.""" - self.assertEqual(rsa.prime.get_primality_testing_rounds(1 << 63), 10) + self.assertEqual(rsa.prime.get_primality_testing_rounds(1 << 63), 10) self.assertEqual(rsa.prime.get_primality_testing_rounds(1 << 127), 10) self.assertEqual(rsa.prime.get_primality_testing_rounds(1 << 255), 10) - self.assertEqual(rsa.prime.get_primality_testing_rounds(1 << 511), 7) - self.assertEqual(rsa.prime.get_primality_testing_rounds(1 << 767), 7) + self.assertEqual(rsa.prime.get_primality_testing_rounds(1 << 511), 7) + self.assertEqual(rsa.prime.get_primality_testing_rounds(1 << 767), 7) self.assertEqual(rsa.prime.get_primality_testing_rounds(1 << 1023), 4) self.assertEqual(rsa.prime.get_primality_testing_rounds(1 << 1279), 4) self.assertEqual(rsa.prime.get_primality_testing_rounds(1 << 1535), 3) diff --git a/tests/test_strings.py b/tests/test_strings.py index e392627..ae8ffe1 100644 --- a/tests/test_strings.py +++ b/tests/test_strings.py @@ -28,7 +28,7 @@ class StringTest(unittest.TestCase): (self.pub, self.priv) = rsa.newkeys(384) def test_enc_dec(self): - message = unicode_string.encode('utf-8') + message = unicode_string.encode("utf-8") print("\n\tMessage: %r" % message) encrypted = rsa.encrypt(message, self.pub) diff --git a/tests/test_transform.py b/tests/test_transform.py index 7b9335e..1404619 100644 --- a/tests/test_transform.py +++ b/tests/test_transform.py @@ -18,20 +18,19 @@ from rsa.transform import int2bytes, bytes2int class Test_int2bytes(unittest.TestCase): def test_accuracy(self): - self.assertEqual(int2bytes(123456789), b'\x07[\xcd\x15') + self.assertEqual(int2bytes(123456789), b"\x07[\xcd\x15") def test_codec_identity(self): self.assertEqual(bytes2int(int2bytes(123456789, 128)), 123456789) def test_chunk_size(self): - self.assertEqual(int2bytes(123456789, 6), b'\x00\x00\x07[\xcd\x15') - self.assertEqual(int2bytes(123456789, 7), - b'\x00\x00\x00\x07[\xcd\x15') + self.assertEqual(int2bytes(123456789, 6), b"\x00\x00\x07[\xcd\x15") + self.assertEqual(int2bytes(123456789, 7), b"\x00\x00\x00\x07[\xcd\x15") def test_zero(self): - self.assertEqual(int2bytes(0, 4), b'\x00' * 4) - self.assertEqual(int2bytes(0, 7), b'\x00' * 7) - self.assertEqual(int2bytes(0), b'\x00') + self.assertEqual(int2bytes(0, 4), b"\x00" * 4) + self.assertEqual(int2bytes(0, 7), b"\x00" * 7) + self.assertEqual(int2bytes(0), b"\x00") def test_correctness_against_base_implementation(self): # Slow test. @@ -41,9 +40,7 @@ class Test_int2bytes(unittest.TestCase): 1 << 77, ] for value in values: - self.assertEqual(bytes2int(int2bytes(value)), - value, - "Boom %d" % value) + self.assertEqual(bytes2int(int2bytes(value)), value, "Boom %d" % value) def test_raises_OverflowError_when_chunk_size_is_insufficient(self): self.assertRaises(OverflowError, int2bytes, 123456789, 3) |