Skip to content

Branch fixes #2079

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 1 commit into from
Jun 27, 2015
Merged

Branch fixes #2079

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
75 changes: 23 additions & 52 deletions tests/hazmat/primitives/test_dsa.py
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -30,21 +30,6 @@
)


def _skip_if_no_serialization(key, backend):
if not isinstance(
key,
(dsa.DSAPrivateKeyWithSerialization, dsa.DSAPublicKeyWithSerialization)
):
pytest.skip(
"{0} does not support DSA key serialization".format(backend)
)


def test_skip_if_no_serialization():
with pytest.raises(pytest.skip.Exception):
_skip_if_no_serialization("notakeywithserialization", "backend")


@utils.register_interface(serialization.KeySerializationEncryption)
class DummyKeyEncryption(object):
pass
Expand Down Expand Up @@ -75,35 +60,33 @@ def test_generate_dsa_keys(self, vector, backend):
g=vector['g']
).parameters(backend)
skey = parameters.generate_private_key()
if isinstance(skey, dsa.DSAPrivateKeyWithSerialization):
numbers = skey.private_numbers()
skey_parameters = numbers.public_numbers.parameter_numbers
pkey = skey.public_key()
parameters = pkey.parameters()
parameter_numbers = parameters.parameter_numbers()
assert parameter_numbers.p == skey_parameters.p
assert parameter_numbers.q == skey_parameters.q
assert parameter_numbers.g == skey_parameters.g
assert skey_parameters.p == vector['p']
assert skey_parameters.q == vector['q']
assert skey_parameters.g == vector['g']
assert skey.key_size == bit_length(vector['p'])
assert pkey.key_size == skey.key_size
public_numbers = pkey.public_numbers()
assert numbers.public_numbers.y == public_numbers.y
assert numbers.public_numbers.y == pow(
skey_parameters.g, numbers.x, skey_parameters.p
)
numbers = skey.private_numbers()
skey_parameters = numbers.public_numbers.parameter_numbers
pkey = skey.public_key()
parameters = pkey.parameters()
parameter_numbers = parameters.parameter_numbers()
assert parameter_numbers.p == skey_parameters.p
assert parameter_numbers.q == skey_parameters.q
assert parameter_numbers.g == skey_parameters.g
assert skey_parameters.p == vector['p']
assert skey_parameters.q == vector['q']
assert skey_parameters.g == vector['g']
assert skey.key_size == bit_length(vector['p'])
assert pkey.key_size == skey.key_size
public_numbers = pkey.public_numbers()
assert numbers.public_numbers.y == public_numbers.y
assert numbers.public_numbers.y == pow(
skey_parameters.g, numbers.x, skey_parameters.p
)

def test_generate_dsa_private_key_and_parameters(self, backend):
skey = dsa.generate_private_key(1024, backend)
assert skey
if isinstance(skey, dsa.DSAPrivateKeyWithSerialization):
numbers = skey.private_numbers()
skey_parameters = numbers.public_numbers.parameter_numbers
assert numbers.public_numbers.y == pow(
skey_parameters.g, numbers.x, skey_parameters.p
)
numbers = skey.private_numbers()
skey_parameters = numbers.public_numbers.parameter_numbers
assert numbers.public_numbers.y == pow(
skey_parameters.g, numbers.x, skey_parameters.p
)

def test_invalid_parameters_values(self, backend):
# Test a p < 1024 bits in length
Expand Down Expand Up @@ -819,7 +802,6 @@ def test_private_bytes_encrypted_pem(self, backend, fmt, password):
lambda pemfile: pemfile.read().encode()
)
key = serialization.load_pem_private_key(key_bytes, None, backend)
_skip_if_no_serialization(key, backend)
serialized = key.private_bytes(
serialization.Encoding.PEM,
fmt,
Expand Down Expand Up @@ -847,7 +829,6 @@ def test_private_bytes_encrypted_der(self, backend, fmt, password):
lambda pemfile: pemfile.read().encode()
)
key = serialization.load_pem_private_key(key_bytes, None, backend)
_skip_if_no_serialization(key, backend)
serialized = key.private_bytes(
serialization.Encoding.DER,
fmt,
Expand Down Expand Up @@ -888,7 +869,6 @@ def test_private_bytes_encrypted_der(self, backend, fmt, password):
def test_private_bytes_unencrypted(self, backend, encoding, fmt,
loader_func):
key = DSA_KEY_1024.private_key(backend)
_skip_if_no_serialization(key, backend)
serialized = key.private_bytes(
encoding, fmt, serialization.NoEncryption()
)
Expand Down Expand Up @@ -934,7 +914,6 @@ def test_private_bytes_traditional_openssl_unencrypted(

def test_private_bytes_traditional_der_encrypted_invalid(self, backend):
key = DSA_KEY_1024.private_key(backend)
_skip_if_no_serialization(key, backend)
with pytest.raises(ValueError):
key.private_bytes(
serialization.Encoding.DER,
Expand All @@ -949,7 +928,6 @@ def test_private_bytes_invalid_encoding(self, backend):
pemfile.read().encode(), None, backend
)
)
_skip_if_no_serialization(key, backend)
with pytest.raises(TypeError):
key.private_bytes(
"notencoding",
Expand All @@ -964,7 +942,6 @@ def test_private_bytes_invalid_format(self, backend):
pemfile.read().encode(), None, backend
)
)
_skip_if_no_serialization(key, backend)
with pytest.raises(TypeError):
key.private_bytes(
serialization.Encoding.PEM,
Expand All @@ -979,7 +956,6 @@ def test_private_bytes_invalid_encryption_algorithm(self, backend):
pemfile.read().encode(), None, backend
)
)
_skip_if_no_serialization(key, backend)
with pytest.raises(TypeError):
key.private_bytes(
serialization.Encoding.PEM,
Expand All @@ -994,7 +970,6 @@ def test_private_bytes_unsupported_encryption_type(self, backend):
pemfile.read().encode(), None, backend
)
)
_skip_if_no_serialization(key, backend)
with pytest.raises(ValueError):
key.private_bytes(
serialization.Encoding.PEM,
Expand Down Expand Up @@ -1030,15 +1005,13 @@ def test_public_bytes_match(self, key_path, loader_func, encoding,
key_path, lambda pemfile: pemfile.read(), mode="rb"
)
key = loader_func(key_bytes, backend)
_skip_if_no_serialization(key, backend)
serialized = key.public_bytes(
encoding, serialization.PublicFormat.SubjectPublicKeyInfo,
)
assert serialized == key_bytes

def test_public_bytes_invalid_encoding(self, backend):
key = DSA_KEY_2048.private_key(backend).public_key()
_skip_if_no_serialization(key, backend)
with pytest.raises(TypeError):
key.public_bytes(
"notencoding",
Expand All @@ -1047,13 +1020,11 @@ def test_public_bytes_invalid_encoding(self, backend):

def test_public_bytes_invalid_format(self, backend):
key = DSA_KEY_2048.private_key(backend).public_key()
_skip_if_no_serialization(key, backend)
with pytest.raises(TypeError):
key.public_bytes(serialization.Encoding.PEM, "invalidformat")

def test_public_bytes_pkcs1_unsupported(self, backend):
key = DSA_KEY_2048.private_key(backend).public_key()
_skip_if_no_serialization(key, backend)
with pytest.raises(ValueError):
key.public_bytes(
serialization.Encoding.PEM, serialization.PublicFormat.PKCS1
Expand Down
41 changes: 5 additions & 36 deletions tests/hazmat/primitives/test_ec.py
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -33,18 +33,6 @@
}


def _skip_if_no_serialization(key, backend):
if not isinstance(
key, (
ec.EllipticCurvePrivateKeyWithSerialization,
ec.EllipticCurvePublicKeyWithSerialization
)
):
pytest.skip(
"{0} does not support EC key serialization".format(backend)
)


def _skip_ecdsa_vector(backend, curve_type, hash_type):
if not backend.elliptic_curve_signature_algorithm_supported(
ec.ECDSA(hash_type()),
Expand Down Expand Up @@ -88,11 +76,6 @@ def test_skip_curve_unsupported(backend):
_skip_curve_unsupported(backend, DummyCurve())


def test_skip_no_serialization():
with pytest.raises(pytest.skip.Exception):
_skip_if_no_serialization("fakebackend", "fakekey")


def test_ec_numbers():
numbers = ec.EllipticCurvePrivateNumbers(
1,
Expand Down Expand Up @@ -173,12 +156,11 @@ def test_with_numbers(self, backend, vector, hash_type):
).private_key(backend)
assert key

if isinstance(key, ec.EllipticCurvePrivateKeyWithSerialization):
priv_num = key.private_numbers()
assert priv_num.private_value == vector['d']
assert priv_num.public_numbers.x == vector['x']
assert priv_num.public_numbers.y == vector['y']
assert curve_type().name == priv_num.public_numbers.curve.name
priv_num = key.private_numbers()
assert priv_num.private_value == vector['d']
assert priv_num.public_numbers.x == vector['x']
assert priv_num.public_numbers.y == vector['y']
assert curve_type().name == priv_num.public_numbers.curve.name


@pytest.mark.requires_backend_interface(interface=EllipticCurveBackend)
Expand Down Expand Up @@ -437,7 +419,6 @@ def test_private_bytes_encrypted_pem(self, backend, fmt, password):
lambda pemfile: pemfile.read().encode()
)
key = serialization.load_pem_private_key(key_bytes, None, backend)
_skip_if_no_serialization(key, backend)
serialized = key.private_bytes(
serialization.Encoding.PEM,
fmt,
Expand Down Expand Up @@ -467,7 +448,6 @@ def test_private_bytes_encrypted_der(self, backend, fmt, password):
lambda pemfile: pemfile.read().encode()
)
key = serialization.load_pem_private_key(key_bytes, None, backend)
_skip_if_no_serialization(key, backend)
serialized = key.private_bytes(
serialization.Encoding.DER,
fmt,
Expand Down Expand Up @@ -514,7 +494,6 @@ def test_private_bytes_unencrypted(self, backend, encoding, fmt,
lambda pemfile: pemfile.read().encode()
)
key = serialization.load_pem_private_key(key_bytes, None, backend)
_skip_if_no_serialization(key, backend)
serialized = key.private_bytes(
encoding, fmt, serialization.NoEncryption()
)
Expand Down Expand Up @@ -566,7 +545,6 @@ def test_private_bytes_traditional_der_encrypted_invalid(self, backend):
pemfile.read().encode(), None, backend
)
)
_skip_if_no_serialization(key, backend)
with pytest.raises(ValueError):
key.private_bytes(
serialization.Encoding.DER,
Expand All @@ -583,7 +561,6 @@ def test_private_bytes_invalid_encoding(self, backend):
pemfile.read().encode(), None, backend
)
)
_skip_if_no_serialization(key, backend)
with pytest.raises(TypeError):
key.private_bytes(
"notencoding",
Expand All @@ -600,7 +577,6 @@ def test_private_bytes_invalid_format(self, backend):
pemfile.read().encode(), None, backend
)
)
_skip_if_no_serialization(key, backend)
with pytest.raises(TypeError):
key.private_bytes(
serialization.Encoding.PEM,
Expand All @@ -617,7 +593,6 @@ def test_private_bytes_invalid_encryption_algorithm(self, backend):
pemfile.read().encode(), None, backend
)
)
_skip_if_no_serialization(key, backend)
with pytest.raises(TypeError):
key.private_bytes(
serialization.Encoding.PEM,
Expand All @@ -634,7 +609,6 @@ def test_private_bytes_unsupported_encryption_type(self, backend):
pemfile.read().encode(), None, backend
)
)
_skip_if_no_serialization(key, backend)
with pytest.raises(ValueError):
key.private_bytes(
serialization.Encoding.PEM,
Expand All @@ -651,7 +625,6 @@ def test_public_bytes_from_derived_public_key(self, backend):
pemfile.read().encode(), None, backend
)
)
_skip_if_no_serialization(key, backend)
public = key.public_key()
pem = public.public_bytes(
serialization.Encoding.PEM,
Expand Down Expand Up @@ -689,7 +662,6 @@ def test_public_bytes_match(self, key_path, loader_func, encoding,
key_path, lambda pemfile: pemfile.read(), mode="rb"
)
key = loader_func(key_bytes, backend)
_skip_if_no_serialization(key, backend)
serialized = key.public_bytes(
encoding, serialization.PublicFormat.SubjectPublicKeyInfo,
)
Expand All @@ -705,7 +677,6 @@ def test_public_bytes_invalid_encoding(self, backend):
pemfile.read().encode(), backend
)
)
_skip_if_no_serialization(key, backend)
with pytest.raises(TypeError):
key.public_bytes(
"notencoding",
Expand All @@ -722,7 +693,6 @@ def test_public_bytes_invalid_format(self, backend):
pemfile.read().encode(), backend
)
)
_skip_if_no_serialization(key, backend)
with pytest.raises(TypeError):
key.public_bytes(serialization.Encoding.PEM, "invalidformat")

Expand All @@ -736,7 +706,6 @@ def test_public_bytes_pkcs1_unsupported(self, backend):
pemfile.read().encode(), backend
)
)
_skip_if_no_serialization(key, backend)
with pytest.raises(ValueError):
key.public_bytes(
serialization.Encoding.PEM, serialization.PublicFormat.PKCS1
Expand Down
Loading