From 1bb60898e88abe4402c241ec7a2e6b5d7db03e6f Mon Sep 17 00:00:00 2001 From: Paul Kehrer Date: Wed, 11 Jun 2014 15:53:58 -0500 Subject: simplify test_rsa changes --- tests/hazmat/primitives/test_rsa.py | 810 +++++++++++++++--------------------- 1 file changed, 343 insertions(+), 467 deletions(-) (limited to 'tests/hazmat/primitives') diff --git a/tests/hazmat/primitives/test_rsa.py b/tests/hazmat/primitives/test_rsa.py index 4dd34c2b..6b65eba5 100644 --- a/tests/hazmat/primitives/test_rsa.py +++ b/tests/hazmat/primitives/test_rsa.py @@ -28,7 +28,7 @@ from cryptography.exceptions import ( from cryptography.hazmat.primitives import hashes, interfaces from cryptography.hazmat.primitives.asymmetric import padding, rsa from cryptography.hazmat.primitives.serialization import ( - load_rsa_private_numbers, load_rsa_public_numbers + load_rsa_private_numbers ) from .fixtures_rsa import ( @@ -98,9 +98,11 @@ class TestRSA(object): ) def test_generate_rsa_keys(self, backend, public_exponent, key_size): skey = rsa.generate_private_key(public_exponent, key_size, backend) - assert skey assert skey.key_size == key_size + if isinstance(skey, interfaces.RSAPrivateKeyWithNumbers): + _check_rsa_private_numbers(skey.private_numbers()) + def test_generate_rsa_key_class_method(self, backend): skey = rsa.RSAPrivateKey.generate(65537, 512, backend) assert skey.key_size == 512 @@ -165,6 +167,218 @@ class TestRSA(object): assert public_num.n == public_num2.n assert public_num.e == public_num2.e + def test_invalid_private_key_argument_types(self): + with pytest.raises(TypeError): + rsa.RSAPrivateKey(None, None, None, None, None, None, None, None) + + def test_invalid_public_key_argument_types(self): + with pytest.raises(TypeError): + rsa.RSAPublicKey(None, None) + + def test_invalid_private_key_argument_values(self): + # Start with p=3, q=11, private_exponent=3, public_exponent=7, + # modulus=33, dmp1=1, dmq1=3, iqmp=2. Then change one value at + # a time to test the bounds. + + # Test a modulus < 3. + with pytest.raises(ValueError): + rsa.RSAPrivateKey( + p=3, + q=11, + private_exponent=3, + dmp1=1, + dmq1=3, + iqmp=2, + public_exponent=7, + modulus=2 + ) + + # Test a modulus != p * q. + with pytest.raises(ValueError): + rsa.RSAPrivateKey( + p=3, + q=11, + private_exponent=3, + dmp1=1, + dmq1=3, + iqmp=2, + public_exponent=7, + modulus=35 + ) + + # Test a p > modulus. + with pytest.raises(ValueError): + rsa.RSAPrivateKey( + p=37, + q=11, + private_exponent=3, + dmp1=1, + dmq1=3, + iqmp=2, + public_exponent=7, + modulus=33 + ) + + # Test a q > modulus. + with pytest.raises(ValueError): + rsa.RSAPrivateKey( + p=3, + q=37, + private_exponent=3, + dmp1=1, + dmq1=3, + iqmp=2, + public_exponent=7, + modulus=33 + ) + + # Test a dmp1 > modulus. + with pytest.raises(ValueError): + rsa.RSAPrivateKey( + p=3, + q=11, + private_exponent=3, + dmp1=35, + dmq1=3, + iqmp=2, + public_exponent=7, + modulus=33 + ) + + # Test a dmq1 > modulus. + with pytest.raises(ValueError): + rsa.RSAPrivateKey( + p=3, + q=11, + private_exponent=3, + dmp1=1, + dmq1=35, + iqmp=2, + public_exponent=7, + modulus=33 + ) + + # Test an iqmp > modulus. + with pytest.raises(ValueError): + rsa.RSAPrivateKey( + p=3, + q=11, + private_exponent=3, + dmp1=1, + dmq1=3, + iqmp=35, + public_exponent=7, + modulus=33 + ) + + # Test a private_exponent > modulus + with pytest.raises(ValueError): + rsa.RSAPrivateKey( + p=3, + q=11, + private_exponent=37, + dmp1=1, + dmq1=3, + iqmp=2, + public_exponent=7, + modulus=33 + ) + + # Test a public_exponent < 3 + with pytest.raises(ValueError): + rsa.RSAPrivateKey( + p=3, + q=11, + private_exponent=3, + dmp1=1, + dmq1=3, + iqmp=2, + public_exponent=1, + modulus=33 + ) + + # Test a public_exponent > modulus + with pytest.raises(ValueError): + rsa.RSAPrivateKey( + p=3, + q=11, + private_exponent=3, + dmp1=1, + dmq1=3, + iqmp=2, + public_exponent=65537, + modulus=33 + ) + + # Test a public_exponent that is not odd. + with pytest.raises(ValueError): + rsa.RSAPrivateKey( + p=3, + q=11, + private_exponent=3, + dmp1=1, + dmq1=3, + iqmp=2, + public_exponent=6, + modulus=33 + ) + + # Test a dmp1 that is not odd. + with pytest.raises(ValueError): + rsa.RSAPrivateKey( + p=3, + q=11, + private_exponent=3, + dmp1=2, + dmq1=3, + iqmp=2, + public_exponent=7, + modulus=33 + ) + + # Test a dmq1 that is not odd. + with pytest.raises(ValueError): + rsa.RSAPrivateKey( + p=3, + q=11, + private_exponent=3, + dmp1=1, + dmq1=4, + iqmp=2, + public_exponent=7, + modulus=33 + ) + + def test_invalid_public_key_argument_values(self): + # Start with public_exponent=7, modulus=15. Then change one value at a + # time to test the bounds. + + # Test a modulus < 3. + with pytest.raises(ValueError): + rsa.RSAPublicKey(public_exponent=7, modulus=2) + + # Test a public_exponent < 3 + with pytest.raises(ValueError): + rsa.RSAPublicKey(public_exponent=1, modulus=15) + + # Test a public_exponent > modulus + with pytest.raises(ValueError): + rsa.RSAPublicKey(public_exponent=17, modulus=15) + + # Test a public_exponent that is not odd. + with pytest.raises(ValueError): + rsa.RSAPublicKey(public_exponent=6, modulus=15) + + +def test_rsa_generate_invalid_backend(): + pretend_backend = object() + + with raises_unsupported_algorithm(_Reasons.BACKEND_MISSING_INTERFACE): + rsa.generate_private_key(65537, 2048, pretend_backend) + + with raises_unsupported_algorithm(_Reasons.BACKEND_MISSING_INTERFACE): + rsa.RSAPrivateKey.generate(65537, 2048, pretend_backend) + @pytest.mark.rsa class TestRSASignature(object): @@ -184,20 +398,17 @@ class TestRSASignature(object): ) def test_pkcs1v15_signing(self, pkcs1_example, backend): private, public, example = pkcs1_example - private_numbers = rsa.RSAPrivateNumbers( + private_key = rsa.RSAPrivateKey( p=private["p"], q=private["q"], - d=private["private_exponent"], + private_exponent=private["private_exponent"], dmp1=private["dmp1"], dmq1=private["dmq1"], iqmp=private["iqmp"], - public_numbers=rsa.RSAPublicNumbers( - e=private["public_exponent"], - n=private["modulus"] - ) + public_exponent=private["public_exponent"], + modulus=private["modulus"] ) - private_key = load_rsa_private_numbers(private_numbers, backend) - signer = private_key.signer(padding.PKCS1v15(), hashes.SHA1()) + signer = private_key.signer(padding.PKCS1v15(), hashes.SHA1(), backend) signer.update(binascii.unhexlify(example["message"])) signature = signer.finalize() assert binascii.hexlify(signature) == example["signature"] @@ -221,30 +432,27 @@ class TestRSASignature(object): ) def test_pss_signing(self, pkcs1_example, backend): private, public, example = pkcs1_example - private_numbers = rsa.RSAPrivateNumbers( + private_key = rsa.RSAPrivateKey( p=private["p"], q=private["q"], - d=private["private_exponent"], + private_exponent=private["private_exponent"], dmp1=private["dmp1"], dmq1=private["dmq1"], iqmp=private["iqmp"], - public_numbers=rsa.RSAPublicNumbers( - e=private["public_exponent"], - n=private["modulus"] - ) + public_exponent=private["public_exponent"], + modulus=private["modulus"] ) - public_numbers = rsa.RSAPublicNumbers( - e=public["public_exponent"], - n=public["modulus"] + public_key = rsa.RSAPublicKey( + public_exponent=public["public_exponent"], + modulus=public["modulus"] ) - private_key = load_rsa_private_numbers(private_numbers, backend) - public_key = load_rsa_public_numbers(public_numbers, backend) signer = private_key.signer( padding.PSS( mgf=padding.MGF1(algorithm=hashes.SHA1()), salt_length=padding.PSS.MAX_LENGTH ), - hashes.SHA1() + hashes.SHA1(), + backend ) signer.update(binascii.unhexlify(example["message"])) signature = signer.finalize() @@ -258,7 +466,8 @@ class TestRSASignature(object): mgf=padding.MGF1(algorithm=hashes.SHA1()), salt_length=padding.PSS.MAX_LENGTH ), - hashes.SHA1() + hashes.SHA1(), + backend ) verifier.update(binascii.unhexlify(example["message"])) verifier.verify() @@ -426,6 +635,23 @@ class TestRSASignature(object): with pytest.raises(TypeError): private_key.signer("notpadding", hashes.SHA1()) + def test_rsa_signer_invalid_backend(self, backend): + pretend_backend = object() + private_key = rsa.RSAPrivateKey( + p=RSA_KEY_512.p, + q=RSA_KEY_512.q, + private_exponent=RSA_KEY_512.d, + dmp1=RSA_KEY_512.dmp1, + dmq1=RSA_KEY_512.dmq1, + iqmp=RSA_KEY_512.iqmp, + public_exponent=RSA_KEY_512.public_numbers.e, + modulus=RSA_KEY_512.public_numbers.n + ) + + with raises_unsupported_algorithm(_Reasons.BACKEND_MISSING_INTERFACE): + private_key.signer( + padding.PKCS1v15(), hashes.SHA256, pretend_backend) + @pytest.mark.supported( only_if=lambda backend: backend.rsa_padding_supported( padding.PSS(mgf=padding.MGF1(hashes.SHA1()), salt_length=0) @@ -461,7 +687,10 @@ class TestRSASignature(object): ) def test_pkcs1_minimum_key_size(self, backend): private_key = load_rsa_private_numbers(RSA_KEY_745, backend) - signer = private_key.signer(padding.PKCS1v15(), hashes.SHA512()) + signer = private_key.signer( + padding.PKCS1v15(), + hashes.SHA512() + ) signer.update(b"no failure") signer.finalize() @@ -484,15 +713,15 @@ class TestRSAVerification(object): ) def test_pkcs1v15_verification(self, pkcs1_example, backend): private, public, example = pkcs1_example - public_numbers = rsa.RSAPublicNumbers( - e=public["public_exponent"], - n=public["modulus"] + public_key = rsa.RSAPublicKey( + public_exponent=public["public_exponent"], + modulus=public["modulus"] ) - public_key = load_rsa_public_numbers(public_numbers, backend) verifier = public_key.verifier( binascii.unhexlify(example["signature"]), padding.PKCS1v15(), - hashes.SHA1() + hashes.SHA1(), + backend ) verifier.update(binascii.unhexlify(example["message"])) verifier.verify() @@ -559,18 +788,18 @@ class TestRSAVerification(object): ) def test_pss_verification(self, pkcs1_example, backend): private, public, example = pkcs1_example - public_numbers = rsa.RSAPublicNumbers( - e=public["public_exponent"], - n=public["modulus"] + public_key = rsa.RSAPublicKey( + public_exponent=public["public_exponent"], + modulus=public["modulus"] ) - public_key = load_rsa_public_numbers(public_numbers, backend) verifier = public_key.verifier( binascii.unhexlify(example["signature"]), padding.PSS( mgf=padding.MGF1(algorithm=hashes.SHA1()), salt_length=20 ), - hashes.SHA1() + hashes.SHA1(), + backend ) verifier.update(binascii.unhexlify(example["message"])) verifier.verify() @@ -585,26 +814,26 @@ class TestRSAVerification(object): skip_message="Does not support PSS." ) def test_invalid_pss_signature_wrong_data(self, backend): - public_numbers = rsa.RSAPublicNumbers( - n=int( + public_key = rsa.RSAPublicKey( + modulus=int( b"dffc2137d5e810cde9e4b4612f5796447218bab913b3fa98bdf7982e4fa6" b"ec4d6653ef2b29fb1642b095befcbea6decc178fb4bed243d3c3592c6854" b"6af2d3f3", 16 ), - e=65537 + public_exponent=65537 ) signature = binascii.unhexlify( b"0e68c3649df91c5bc3665f96e157efa75b71934aaa514d91e94ca8418d100f45" b"6f05288e58525f99666bab052adcffdf7186eb40f583bd38d98c97d3d524808b" ) - public_key = load_rsa_public_numbers(public_numbers, backend) verifier = public_key.verifier( signature, padding.PSS( mgf=padding.MGF1(algorithm=hashes.SHA1()), salt_length=padding.PSS.MAX_LENGTH ), - hashes.SHA1() + hashes.SHA1(), + backend ) verifier.update(b"incorrect data") with pytest.raises(InvalidSignature): @@ -624,24 +853,24 @@ class TestRSAVerification(object): b"3a1880165014ba6eb53cc1449d13e5132ebcc0cfd9ade6d7a2494a0503bd0826" b"f8a46c431e0d7be0ca3e453f8b2b009e2733764da7927cc6dbe7a021437a242e" ) - public_numbers = rsa.RSAPublicNumbers( - n=int( + public_key = rsa.RSAPublicKey( + modulus=int( b"381201f4905d67dfeb3dec131a0fbea773489227ec7a1448c3109189ac68" b"5a95441be90866a14c4d2e139cd16db540ec6c7abab13ffff91443fd46a8" b"960cbb7658ded26a5c95c86f6e40384e1c1239c63e541ba221191c4dd303" b"231b42e33c6dbddf5ec9a746f09bf0c25d0f8d27f93ee0ae5c0d723348f4" b"030d3581e13522e1", 16 ), - e=65537 + public_exponent=65537 ) - public_key = load_rsa_public_numbers(public_numbers, backend) verifier = public_key.verifier( signature, padding.PSS( mgf=padding.MGF1(algorithm=hashes.SHA1()), salt_length=padding.PSS.MAX_LENGTH ), - hashes.SHA1() + hashes.SHA1(), + backend ) verifier.update(b"sign me") with pytest.raises(InvalidSignature): @@ -661,24 +890,24 @@ class TestRSAVerification(object): b"cb43bde4f7ab89eb4a79c6e8dd67e0d1af60715da64429d90c716a490b799c29" b"194cf8046509c6ed851052367a74e2e92d9b38947ed74332acb115a03fcc0222" ) - public_numbers = rsa.RSAPublicNumbers( - n=int( + public_key = rsa.RSAPublicKey( + modulus=int( b"381201f4905d67dfeb3dec131a0fbea773489227ec7a1448c3109189ac68" b"5a95441be90866a14c4d2e139cd16db540ec6c7abab13ffff91443fd46a8" b"960cbb7658ded26a5c95c86f6e40384e1c1239c63e541ba221191c4dd303" b"231b42e33c6dbddf5ec9a746f09bf0c25d0f8d27f93ee0ae5c0d723348f4" b"030d3581e13522", 16 ), - e=65537 + public_exponent=65537 ) - public_key = load_rsa_public_numbers(public_numbers, backend) verifier = public_key.verifier( signature, padding.PSS( mgf=padding.MGF1(algorithm=hashes.SHA1()), salt_length=padding.PSS.MAX_LENGTH ), - hashes.SHA1() + hashes.SHA1(), + backend ) verifier.update(b"sign me") with pytest.raises(InvalidSignature): @@ -721,6 +950,15 @@ class TestRSAVerification(object): with pytest.raises(TypeError): public_key.verifier(b"sig", "notpadding", hashes.SHA1()) + def test_rsa_verifier_invalid_backend(self, backend): + pretend_backend = object() + private_key = rsa.RSAPrivateKey.generate(65537, 2048, backend) + public_key = private_key.public_key() + + with raises_unsupported_algorithm(_Reasons.BACKEND_MISSING_INTERFACE): + public_key.verifier( + b"foo", padding.PKCS1v15(), hashes.SHA256(), pretend_backend) + @pytest.mark.supported( only_if=lambda backend: backend.rsa_padding_supported( padding.PSS(mgf=padding.MGF1(hashes.SHA1()), salt_length=0) @@ -778,15 +1016,14 @@ class TestRSAVerification(object): b"8b9a3ae9fb3b64158f3476dd8d8a1f1425444e98940e0926378baa9944d219d8" b"534c050ef6b19b1bdc6eb4da422e89161106a6f5b5cc16135b11eb6439b646bd" ) - public_numbers = rsa.RSAPublicNumbers( - n=int( + public_key = rsa.RSAPublicKey( + modulus=int( b"d309e4612809437548b747d7f9eb9cd3340f54fe42bb3f84a36933b0839c" b"11b0c8b7f67e11f7252370161e31159c49c784d4bc41c42a78ce0f0b40a3" b"ca8ffb91", 16 ), - e=65537 + public_exponent=65537 ) - public_key = load_rsa_public_numbers(public_numbers, backend) verifier = public_key.verifier( signature, padding.PSS( @@ -795,7 +1032,8 @@ class TestRSAVerification(object): ), salt_length=1000000 ), - hashes.SHA1() + hashes.SHA1(), + backend ) verifier.update(b"sign me") with pytest.raises(InvalidSignature): @@ -1129,22 +1367,23 @@ class TestRSADecryption(object): ) def test_decrypt_pkcs1v15_vectors(self, vector, backend): private, public, example = vector - private_numbers = rsa.RSAPrivateNumbers( + skey = rsa.RSAPrivateKey( p=private["p"], q=private["q"], - d=private["private_exponent"], + private_exponent=private["private_exponent"], dmp1=private["dmp1"], dmq1=private["dmq1"], iqmp=private["iqmp"], - public_numbers=rsa.RSAPublicNumbers( - e=private["public_exponent"], - n=private["modulus"] - ) + public_exponent=private["public_exponent"], + modulus=private["modulus"] ) - private = load_rsa_private_numbers(private_numbers, backend) ciphertext = binascii.unhexlify(example["encryption"]) - assert len(ciphertext) == math.ceil(private.key_size / 8.0) - message = private.decrypt(ciphertext, padding.PKCS1v15()) + assert len(ciphertext) == math.ceil(skey.key_size / 8.0) + message = skey.decrypt( + ciphertext, + padding.PKCS1v15(), + backend + ) assert message == binascii.unhexlify(example["message"]) def test_unsupported_padding(self, backend): @@ -1198,6 +1437,17 @@ class TestRSADecryption(object): padding.PKCS1v15() ) + def test_rsa_decrypt_invalid_backend(self, backend): + pretend_backend = object() + private_key = rsa.RSAPrivateKey.generate(65537, 2048, backend) + + with raises_unsupported_algorithm(_Reasons.BACKEND_MISSING_INTERFACE): + private_key.decrypt( + b"irrelevant", + padding.PKCS1v15(), + pretend_backend + ) + @pytest.mark.supported( only_if=lambda backend: backend.rsa_padding_supported( padding.OAEP( @@ -1218,26 +1468,24 @@ class TestRSADecryption(object): ) def test_decrypt_oaep_vectors(self, vector, backend): private, public, example = vector - private_numbers = rsa.RSAPrivateNumbers( + skey = rsa.RSAPrivateKey( p=private["p"], q=private["q"], - d=private["private_exponent"], + private_exponent=private["private_exponent"], dmp1=private["dmp1"], dmq1=private["dmq1"], iqmp=private["iqmp"], - public_numbers=rsa.RSAPublicNumbers( - e=private["public_exponent"], - n=private["modulus"] - ) + public_exponent=private["public_exponent"], + modulus=private["modulus"] ) - skey = load_rsa_private_numbers(private_numbers, backend) message = skey.decrypt( binascii.unhexlify(example["encryption"]), padding.OAEP( mgf=padding.MGF1(algorithm=hashes.SHA1()), algorithm=hashes.SHA1(), label=None - ) + ), + backend ) assert message == binascii.unhexlify(example["message"]) @@ -1282,13 +1530,22 @@ class TestRSAEncryption(object): ) ) def test_rsa_encrypt_oaep(self, key_data, pad, backend): - private_key = load_rsa_private_numbers(key_data, backend) + private_key = rsa.RSAPrivateKey( + p=key_data.p, + q=key_data.q, + private_exponent=key_data.d, + dmp1=key_data.dmp1, + dmq1=key_data.dmq1, + iqmp=key_data.iqmp, + public_exponent=key_data.public_numbers.e, + modulus=key_data.public_numbers.n + ) pt = b"encrypt me!" public_key = private_key.public_key() - ct = public_key.encrypt(pt, pad) + ct = public_key.encrypt(pt, pad, backend) assert ct != pt assert len(ct) == math.ceil(public_key.key_size / 8.0) - recovered_pt = private_key.decrypt(ct, pad) + recovered_pt = private_key.decrypt(ct, pad, backend) assert recovered_pt == pt @pytest.mark.supported( @@ -1349,6 +1606,18 @@ class TestRSAEncryption(object): pad ) + def test_rsa_encrypt_invalid_backend(self, backend): + pretend_backend = object() + private_key = rsa.RSAPrivateKey.generate(65537, 512, backend) + public_key = private_key.public_key() + + with raises_unsupported_algorithm(_Reasons.BACKEND_MISSING_INTERFACE): + public_key.encrypt( + b"irrelevant", + padding.PKCS1v15(), + pretend_backend + ) + def test_unsupported_padding(self, backend): private_key = load_rsa_private_numbers(RSA_KEY_512, backend) public_key = private_key.public_key() @@ -1731,396 +2000,3 @@ class TestRSANumbers(object): ) ) ) - - -@pytest.mark.rsa -class TestDeprecatedRSA(object): - def test_deprecated_invalid_private_key_argument_types(self): - with pytest.raises(TypeError): - rsa.RSAPrivateKey(None, None, None, None, None, None, None, None) - - def test_deprecated_invalid_public_key_argument_types(self): - with pytest.raises(TypeError): - rsa.RSAPublicKey(None, None) - - def test_deprecated_invalid_private_key_argument_values(self): - # This can be removed when we finish deprecation for DeprecatedIn05 - - # Start with p=3, q=11, private_exponent=3, public_exponent=7, - # modulus=33, dmp1=1, dmq1=3, iqmp=2. Then change one value at - # a time to test the bounds. - - # Test a modulus < 3. - with pytest.raises(ValueError): - rsa.RSAPrivateKey( - p=3, - q=11, - private_exponent=3, - dmp1=1, - dmq1=3, - iqmp=2, - public_exponent=7, - modulus=2 - ) - - # Test a modulus != p * q. - with pytest.raises(ValueError): - rsa.RSAPrivateKey( - p=3, - q=11, - private_exponent=3, - dmp1=1, - dmq1=3, - iqmp=2, - public_exponent=7, - modulus=35 - ) - - # Test a p > modulus. - with pytest.raises(ValueError): - rsa.RSAPrivateKey( - p=37, - q=11, - private_exponent=3, - dmp1=1, - dmq1=3, - iqmp=2, - public_exponent=7, - modulus=33 - ) - - # Test a q > modulus. - with pytest.raises(ValueError): - rsa.RSAPrivateKey( - p=3, - q=37, - private_exponent=3, - dmp1=1, - dmq1=3, - iqmp=2, - public_exponent=7, - modulus=33 - ) - - # Test a dmp1 > modulus. - with pytest.raises(ValueError): - rsa.RSAPrivateKey( - p=3, - q=11, - private_exponent=3, - dmp1=35, - dmq1=3, - iqmp=2, - public_exponent=7, - modulus=33 - ) - - # Test a dmq1 > modulus. - with pytest.raises(ValueError): - rsa.RSAPrivateKey( - p=3, - q=11, - private_exponent=3, - dmp1=1, - dmq1=35, - iqmp=2, - public_exponent=7, - modulus=33 - ) - - # Test an iqmp > modulus. - with pytest.raises(ValueError): - rsa.RSAPrivateKey( - p=3, - q=11, - private_exponent=3, - dmp1=1, - dmq1=3, - iqmp=35, - public_exponent=7, - modulus=33 - ) - - # Test a private_exponent > modulus - with pytest.raises(ValueError): - rsa.RSAPrivateKey( - p=3, - q=11, - private_exponent=37, - dmp1=1, - dmq1=3, - iqmp=2, - public_exponent=7, - modulus=33 - ) - - # Test a public_exponent < 3 - with pytest.raises(ValueError): - rsa.RSAPrivateKey( - p=3, - q=11, - private_exponent=3, - dmp1=1, - dmq1=3, - iqmp=2, - public_exponent=1, - modulus=33 - ) - - # Test a public_exponent > modulus - with pytest.raises(ValueError): - rsa.RSAPrivateKey( - p=3, - q=11, - private_exponent=3, - dmp1=1, - dmq1=3, - iqmp=2, - public_exponent=65537, - modulus=33 - ) - - # Test a public_exponent that is not odd. - with pytest.raises(ValueError): - rsa.RSAPrivateKey( - p=3, - q=11, - private_exponent=3, - dmp1=1, - dmq1=3, - iqmp=2, - public_exponent=6, - modulus=33 - ) - - # Test a dmp1 that is not odd. - with pytest.raises(ValueError): - rsa.RSAPrivateKey( - p=3, - q=11, - private_exponent=3, - dmp1=2, - dmq1=3, - iqmp=2, - public_exponent=7, - modulus=33 - ) - - # Test a dmq1 that is not odd. - with pytest.raises(ValueError): - rsa.RSAPrivateKey( - p=3, - q=11, - private_exponent=3, - dmp1=1, - dmq1=4, - iqmp=2, - public_exponent=7, - modulus=33 - ) - - def test_deprecated_invalid_public_key_argument_values(self): - # This can be removed when we finish deprecation for DeprecatedIn05 - - # Start with public_exponent=7, modulus=15. Then change one value at a - # time to test the bounds. - - # Test a modulus < 3. - with pytest.raises(ValueError): - rsa.RSAPublicKey(public_exponent=7, modulus=2) - - # Test a public_exponent < 3 - with pytest.raises(ValueError): - rsa.RSAPublicKey(public_exponent=1, modulus=15) - - # Test a public_exponent > modulus - with pytest.raises(ValueError): - rsa.RSAPublicKey(public_exponent=17, modulus=15) - - # Test a public_exponent that is not odd. - with pytest.raises(ValueError): - rsa.RSAPublicKey(public_exponent=6, modulus=15) - - def test_rsa_deprecated_generate_invalid_backend(self): - # This can be removed when we finish deprecation for DeprecatedIn05 - pretend_backend = object() - - with raises_unsupported_algorithm(_Reasons.BACKEND_MISSING_INTERFACE): - rsa.generate_private_key(65537, 2048, pretend_backend) - - with raises_unsupported_algorithm(_Reasons.BACKEND_MISSING_INTERFACE): - rsa.RSAPrivateKey.generate(65537, 2048, pretend_backend) - - @pytest.mark.supported( - only_if=lambda backend: backend.rsa_padding_supported( - padding.PKCS1v15() - ), - skip_message="Does not support PKCS1v1.5." - ) - @pytest.mark.parametrize( - "pkcs1_example", - _flatten_pkcs1_examples(load_vectors_from_file( - os.path.join( - "asymmetric", "RSA", "pkcs1v15sign-vectors.txt"), - load_pkcs1_vectors - )) - ) - def test_deprecated_pkcs1v15_signing(self, pkcs1_example, backend): - # This can be removed when we finish deprecation for DeprecatedIn05 - - private, public, example = pkcs1_example - private_key = rsa.RSAPrivateKey( - p=private["p"], - q=private["q"], - private_exponent=private["private_exponent"], - dmp1=private["dmp1"], - dmq1=private["dmq1"], - iqmp=private["iqmp"], - public_exponent=private["public_exponent"], - modulus=private["modulus"] - ) - signer = private_key.signer(padding.PKCS1v15(), hashes.SHA1(), backend) - signer.update(binascii.unhexlify(example["message"])) - signature = signer.finalize() - assert binascii.hexlify(signature) == example["signature"] - - def test_rsa_deprecated_signer_invalid_backend(self, backend): - # This can be removed when we finish deprecation for DeprecatedIn05 - pretend_backend = object() - private_key = rsa.RSAPrivateKey( - p=RSA_KEY_2048.p, - q=RSA_KEY_2048.q, - private_exponent=RSA_KEY_2048.d, - dmp1=RSA_KEY_2048.dmp1, - dmq1=RSA_KEY_2048.dmq1, - iqmp=RSA_KEY_2048.iqmp, - public_exponent=RSA_KEY_2048.public_numbers.e, - modulus=RSA_KEY_2048.public_numbers.n - ) - - with raises_unsupported_algorithm(_Reasons.BACKEND_MISSING_INTERFACE): - private_key.signer( - padding.PKCS1v15(), hashes.SHA256, pretend_backend) - - def test_rsa_deprecated_verifier_invalid_backend(self, backend): - # This can be removed when we finish deprecation for DeprecatedIn05 - pretend_backend = object() - private_key = rsa.RSAPrivateKey( - p=RSA_KEY_2048.p, - q=RSA_KEY_2048.q, - private_exponent=RSA_KEY_2048.d, - dmp1=RSA_KEY_2048.dmp1, - dmq1=RSA_KEY_2048.dmq1, - iqmp=RSA_KEY_2048.iqmp, - public_exponent=RSA_KEY_2048.public_numbers.e, - modulus=RSA_KEY_2048.public_numbers.n - ) - public_key = private_key.public_key() - - with raises_unsupported_algorithm(_Reasons.BACKEND_MISSING_INTERFACE): - public_key.verifier( - b"foo", padding.PKCS1v15(), hashes.SHA256(), pretend_backend) - - def test_rsa_decrypt_invalid_backend(self, backend): - # This can be removed when we finish deprecation for DeprecatedIn05 - pretend_backend = object() - private_key = rsa.RSAPrivateKey( - p=RSA_KEY_2048.p, - q=RSA_KEY_2048.q, - private_exponent=RSA_KEY_2048.d, - dmp1=RSA_KEY_2048.dmp1, - dmq1=RSA_KEY_2048.dmq1, - iqmp=RSA_KEY_2048.iqmp, - public_exponent=RSA_KEY_2048.public_numbers.e, - modulus=RSA_KEY_2048.public_numbers.n - ) - - with raises_unsupported_algorithm(_Reasons.BACKEND_MISSING_INTERFACE): - private_key.decrypt( - b"irrelevant", - padding.PKCS1v15(), - pretend_backend - ) - - @pytest.mark.supported( - only_if=lambda backend: backend.rsa_padding_supported( - padding.PKCS1v15() - ), - skip_message="Does not support PKCS1v1.5." - ) - def test_deprecated_rsa_encrypt_pkcs1v15(self, backend): - # This can be removed when we finish deprecation for DeprecatedIn05 - private_key = rsa.RSAPrivateKey( - p=RSA_KEY_1024.p, - q=RSA_KEY_1024.q, - private_exponent=RSA_KEY_1024.d, - dmp1=RSA_KEY_1024.dmp1, - dmq1=RSA_KEY_1024.dmq1, - iqmp=RSA_KEY_1024.iqmp, - public_exponent=RSA_KEY_1024.public_numbers.e, - modulus=RSA_KEY_1024.public_numbers.n - ) - pt = b"encrypt me!" - public_key = private_key.public_key() - pad = padding.PKCS1v15() - ct = public_key.encrypt(pt, pad, backend) - assert ct != pt - assert len(ct) == math.ceil(public_key.key_size / 8.0) - recovered_pt = private_key.decrypt(ct, pad, backend) - assert recovered_pt == pt - - def test_rsa_deprecated_encrypt_invalid_backend(self, backend): - # This can be removed when we finish deprecation for DeprecatedIn05 - pretend_backend = object() - private_key = rsa.RSAPrivateKey( - p=RSA_KEY_2048.p, - q=RSA_KEY_2048.q, - private_exponent=RSA_KEY_2048.d, - dmp1=RSA_KEY_2048.dmp1, - dmq1=RSA_KEY_2048.dmq1, - iqmp=RSA_KEY_2048.iqmp, - public_exponent=RSA_KEY_2048.public_numbers.e, - modulus=RSA_KEY_2048.public_numbers.n - ) - public_key = private_key.public_key() - - with raises_unsupported_algorithm(_Reasons.BACKEND_MISSING_INTERFACE): - public_key.encrypt( - b"irrelevant", - padding.PKCS1v15(), - pretend_backend - ) - - @pytest.mark.supported( - only_if=lambda backend: backend.rsa_padding_supported( - padding.OAEP( - mgf=padding.MGF1(algorithm=hashes.SHA1()), - algorithm=hashes.SHA1(), - label=None - ) - ), - skip_message="Does not support OAEP." - ) - def test_rsa_deprecated_decrypt_oaep(self, backend): - private_key = rsa.RSAPrivateKey( - p=RSA_KEY_2048.p, - q=RSA_KEY_2048.q, - private_exponent=RSA_KEY_2048.d, - dmp1=RSA_KEY_2048.dmp1, - dmq1=RSA_KEY_2048.dmq1, - iqmp=RSA_KEY_2048.iqmp, - public_exponent=RSA_KEY_2048.public_numbers.e, - modulus=RSA_KEY_2048.public_numbers.n - ) - pt = b"encrypt me!" - public_key = private_key.public_key() - pad = padding.OAEP( - mgf=padding.MGF1(algorithm=hashes.SHA1()), - algorithm=hashes.SHA1(), - label=None - ) - ct = public_key.encrypt(pt, pad, backend) - assert ct != pt - assert len(ct) == math.ceil(public_key.key_size / 8.0) - recovered_pt = private_key.decrypt(ct, pad, backend) - assert recovered_pt == pt -- cgit v1.2.3