def read(self, input_stream, kmip_version=enums.KMIPVersion.KMIP_1_0):
"""
Read the data encoding the SignatureVerify request payload and decode
it into its constituent parts.
Args:
input_stream (stream): A data stream containing encoded object
data, supporting a read method; usually a BytearrayStream
object.
kmip_version (KMIPVersion): An enumeration defining the KMIP
version with which the object will be decoded. Optional,
defaults to KMIP 1.0.
Raises:
ValueError: Raised if the data attribute is missing from the
encoded payload.
"""
super(SignatureVerifyRequestPayload,
self).read(input_stream, kmip_version=kmip_version)
local_stream = utils.BytearrayStream(input_stream.read(self.length))
if self.is_tag_next(enums.Tags.UNIQUE_IDENTIFIER, local_stream):
self._unique_identifier = primitives.TextString(
tag=enums.Tags.UNIQUE_IDENTIFIER)
self._unique_identifier.read(local_stream,
kmip_version=kmip_version)
if self.is_tag_next(enums.Tags.CRYPTOGRAPHIC_PARAMETERS, local_stream):
self._cryptographic_parameters = \
attributes.CryptographicParameters()
self._cryptographic_parameters.read(local_stream,
kmip_version=kmip_version)
if self.is_tag_next(enums.Tags.DATA, local_stream):
self._data = primitives.ByteString(tag=enums.Tags.DATA)
self._data.read(local_stream, kmip_version=kmip_version)
if self.is_tag_next(enums.Tags.DIGESTED_DATA, local_stream):
self._digested_data = primitives.ByteString(
tag=enums.Tags.DIGESTED_DATA)
self._digested_data.read(local_stream, kmip_version=kmip_version)
if self.is_tag_next(enums.Tags.SIGNATURE_DATA, local_stream):
self._signature_data = primitives.ByteString(
tag=enums.Tags.SIGNATURE_DATA)
self._signature_data.read(local_stream, kmip_version=kmip_version)
if self.is_tag_next(enums.Tags.CORRELATION_VALUE, local_stream):
self._correlation_value = primitives.ByteString(
tag=enums.Tags.CORRELATION_VALUE)
self._correlation_value.read(local_stream,
kmip_version=kmip_version)
if self.is_tag_next(enums.Tags.INIT_INDICATOR, local_stream):
self._init_indicator = primitives.Boolean(
tag=enums.Tags.INIT_INDICATOR)
self._init_indicator.read(local_stream, kmip_version=kmip_version)
if self.is_tag_next(enums.Tags.FINAL_INDICATOR, local_stream):
self._final_indicator = primitives.Boolean(
tag=enums.Tags.FINAL_INDICATOR)
self._final_indicator.read(local_stream, kmip_version=kmip_version)
self.is_oversized(local_stream)
def test_equal_on_equal_and_empty(self):
"""
Test that the equality operator returns True when comparing two
Boolean objects.
"""
a = primitives.Boolean()
b = primitives.Boolean()
self.assertTrue(a == b)
self.assertTrue(b == a)
def test_not_equal_on_equal(self):
"""
Test that the inequality operator returns False when comparing
two Boolean objects with the same values.
"""
a = primitives.Boolean(False)
b = primitives.Boolean(False)
self.assertFalse(a != b)
self.assertFalse(b != a)
def test_not_equal_on_not_equal(self):
"""
Test that the inequality operator returns True when comparing two
Boolean objects with different values.
"""
a = primitives.Boolean(True)
b = primitives.Boolean(False)
self.assertTrue(a != b)
self.assertTrue(b != a)
def test_not_equal_on_equal_and_empty(self):
"""
Test that the inequality operator returns False when comparing
two Boolean objects.
"""
a = primitives.Boolean()
b = primitives.Boolean()
self.assertFalse(a != b)
self.assertFalse(b != a)
def test_repr_false(self):
"""
Test that the representation of a Boolean object representing the
value False is formatted properly.
"""
boolean = primitives.Boolean(False)
self.assertEqual("Boolean(value=False)", repr(boolean))
def read(self, istream, kmip_version=enums.KMIPVersion.KMIP_1_0):
super(RequestBatchItem, self).read(
istream,
kmip_version=kmip_version
)
tstream = BytearrayStream(istream.read(self.length))
# Read the batch item operation
self.operation = contents.Operation()
self.operation.read(tstream, kmip_version=kmip_version)
if kmip_version >= enums.KMIPVersion.KMIP_2_0:
if self.is_tag_next(enums.Tags.EPHEMERAL, tstream):
ephemeral = primitives.Boolean(tag=enums.Tags.EPHEMERAL)
ephemeral.read(tstream, kmip_version=kmip_version)
self._ephemeral = ephemeral
# Read the unique batch item ID if it is present
if self.is_tag_next(Tags.UNIQUE_BATCH_ITEM_ID, tstream):
self.unique_batch_item_id = contents.UniqueBatchItemID()
self.unique_batch_item_id.read(tstream, kmip_version=kmip_version)
# Dynamically create the response payload class that belongs to the
# operation
self.request_payload = self.payload_factory.create(
self.operation.value)
self.request_payload.read(tstream, kmip_version=kmip_version)
# Read the message extension if it is present
if self.is_tag_next(Tags.MESSAGE_EXTENSION, tstream):
self.message_extension = contents.MessageExtension()
self.message_extension.read(tstream, kmip_version=kmip_version)
self.is_oversized(tstream)
def final_indicator(self, value):
if value is None:
self._final_indicator = None
elif isinstance(value, bool):
self._final_indicator = primitives.Boolean(
value=value, tag=enums.Tags.FINAL_INDICATOR)
else:
raise TypeError("Final indicator must be a boolean.")
def test_read_bad_encoding(self):
"""
Test that an Exception is raised when the Boolean read operation fails
on a bad encoding.
"""
encoding = (b'\x42\x00\x00\x06\x00\x00\x00\x08')
stream = utils.BytearrayStream(encoding)
boolean = primitives.Boolean()
self.assertRaises(Exception, boolean.read, stream)
def test_write_bad_value(self):
"""
Test that an Exception is raised when the Boolean write operation fails
on a bad Boolean value.
"""
stream = utils.BytearrayStream()
boolean = primitives.Boolean()
boolean.value = 'invalid'
self.assertRaises(Exception, boolean.write, stream)
def test_not_equal_on_type_mismatch(self):
"""
Test that the inequality operator returns True when comparing a
Boolean object to a non-Boolean object.
"""
a = primitives.Boolean()
b = 'invalid'
self.assertTrue(a != b)
self.assertTrue(b != a)
def test_equal_on_type_mismatch(self):
"""
Test that the equality operator returns False when comparing a
Boolean object to a non-Boolean object.
"""
a = primitives.Boolean()
b = 'invalid'
self.assertFalse(a == b)
self.assertFalse(b == a)
def test_read_bad_value(self):
"""
Test that a ValueError is raised when the Boolean read operations
reads a valid integer but invalid Boolean.
"""
encoding = (
b'\x42\x00\x00\x06\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00'
b'\x02')
stream = utils.BytearrayStream(encoding)
boolean = primitives.Boolean()
self.assertRaises(ValueError, boolean.read, stream)
def ephemeral(self, value):
if value is None:
self._ephemeral = None
elif isinstance(value, bool):
ephemeral = primitives.Boolean(
value=value,
tag=enums.Tags.EPHEMERAL
)
self._ephemeral = ephemeral
else:
raise TypeError("The ephemeral value must be a boolean.")
def test_read_false(self):
"""
Test that a Boolean object representing the value False can be read
from a byte stream.
"""
encoding = (
b'\x42\x00\x00\x06\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00'
b'\x00')
stream = utils.BytearrayStream(encoding)
boolean = primitives.Boolean()
boolean.read(stream)
self.assertFalse(boolean.value)
def test_write_false(self):
"""
Test that a Boolean object representing the value False can be written
to a byte stream.
"""
encoding = (
b'\x42\x00\x00\x06\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00'
b'\x00')
stream = utils.BytearrayStream()
boolean = primitives.Boolean(False)
boolean.write(stream)
self.assertEqual(encoding, stream.read())
def create_attribute_value(self, name, value):
# Switch on the name of the attribute
if name is enums.AttributeType.UNIQUE_IDENTIFIER:
return attributes.UniqueIdentifier(value)
elif name is enums.AttributeType.NAME:
return self._create_name(value)
elif name is enums.AttributeType.OBJECT_TYPE:
return attributes.ObjectType(value)
elif name is enums.AttributeType.CRYPTOGRAPHIC_ALGORITHM:
return attributes.CryptographicAlgorithm(value)
elif name is enums.AttributeType.CRYPTOGRAPHIC_LENGTH:
return self._create_cryptographic_length(value)
elif name is enums.AttributeType.CRYPTOGRAPHIC_PARAMETERS:
return self._create_cryptographic_parameters(value)
elif name is enums.AttributeType.CRYPTOGRAPHIC_DOMAIN_PARAMETERS:
raise NotImplementedError()
elif name is enums.AttributeType.CERTIFICATE_TYPE:
raise NotImplementedError()
elif name is enums.AttributeType.CERTIFICATE_LENGTH:
return primitives.Integer(value, enums.Tags.CERTIFICATE_LENGTH)
elif name is enums.AttributeType.X_509_CERTIFICATE_IDENTIFIER:
raise NotImplementedError()
elif name is enums.AttributeType.X_509_CERTIFICATE_SUBJECT:
raise NotImplementedError()
elif name is enums.AttributeType.X_509_CERTIFICATE_ISSUER:
raise NotImplementedError()
elif name is enums.AttributeType.CERTIFICATE_IDENTIFIER:
raise NotImplementedError()
elif name is enums.AttributeType.CERTIFICATE_SUBJECT:
raise NotImplementedError()
elif name is enums.AttributeType.CERTIFICATE_ISSUER:
raise NotImplementedError()
elif name is enums.AttributeType.DIGITAL_SIGNATURE_ALGORITHM:
raise NotImplementedError()
elif name is enums.AttributeType.DIGEST:
return attributes.Digest()
elif name is enums.AttributeType.OPERATION_POLICY_NAME:
return attributes.OperationPolicyName(value)
elif name is enums.AttributeType.CRYPTOGRAPHIC_USAGE_MASK:
return self._create_cryptographic_usage_mask(value)
elif name is enums.AttributeType.LEASE_TIME:
return primitives.Interval(value, enums.Tags.LEASE_TIME)
elif name is enums.AttributeType.USAGE_LIMITS:
raise NotImplementedError()
elif name is enums.AttributeType.STATE:
return attributes.State(value)
elif name is enums.AttributeType.INITIAL_DATE:
return primitives.DateTime(value, enums.Tags.INITIAL_DATE)
elif name is enums.AttributeType.ACTIVATION_DATE:
return primitives.DateTime(value, enums.Tags.ACTIVATION_DATE)
elif name is enums.AttributeType.PROCESS_START_DATE:
return primitives.DateTime(value, enums.Tags.PROCESS_START_DATE)
elif name is enums.AttributeType.PROTECT_STOP_DATE:
return primitives.DateTime(value, enums.Tags.PROTECT_STOP_DATE)
elif name is enums.AttributeType.DEACTIVATION_DATE:
return primitives.DateTime(value, enums.Tags.DEACTIVATION_DATE)
elif name is enums.AttributeType.DESTROY_DATE:
return primitives.DateTime(value, enums.Tags.DESTROY_DATE)
elif name is enums.AttributeType.COMPROMISE_OCCURRENCE_DATE:
return primitives.DateTime(value,
enums.Tags.COMPROMISE_OCCURRENCE_DATE)
elif name is enums.AttributeType.COMPROMISE_DATE:
return primitives.DateTime(value, enums.Tags.COMPROMISE_DATE)
elif name is enums.AttributeType.REVOCATION_REASON:
raise NotImplementedError()
elif name is enums.AttributeType.ARCHIVE_DATE:
return primitives.DateTime(value, enums.Tags.ARCHIVE_DATE)
elif name is enums.AttributeType.OBJECT_GROUP:
return self._create_object_group(value)
elif name is enums.AttributeType.FRESH:
return primitives.Boolean(value, enums.Tags.FRESH)
elif name is enums.AttributeType.LINK:
raise NotImplementedError()
elif name is enums.AttributeType.APPLICATION_SPECIFIC_INFORMATION:
return self._create_application_specific_information(value)
elif name is enums.AttributeType.CONTACT_INFORMATION:
return self._create_contact_information(value)
elif name is enums.AttributeType.LAST_CHANGE_DATE:
return primitives.DateTime(value, enums.Tags.LAST_CHANGE_DATE)
elif name is enums.AttributeType.CUSTOM_ATTRIBUTE:
return attributes.CustomAttribute(value)
else:
if not isinstance(name, str):
raise ValueError('Unrecognized attribute type: '
'{0}'.format(name))
elif name.startswith('x-'):
# Custom attribute indicated
return attributes.CustomAttribute(value)
def test_validate_on_valid_unset(self):
"""
Test that a Boolean object with no preset value can be validated.
"""
boolean = primitives.Boolean()
boolean.validate()
def test_validate_on_valid(self):
"""
Test that a Boolean object can be validated on good input.
"""
boolean = primitives.Boolean(True)
boolean.validate()
def test_init_unset(self):
"""
Test that a Boolean object can be instantiated with no input.
"""
boolean = primitives.Boolean()
self.assertEqual(True, boolean.value)
def test_str_false(self):
"""
Test that the string representation of a Boolean object representing
the value False is formatted properly.
"""
self.assertEqual("False", str(primitives.Boolean(False)))
def test_repr_default(self):
"""
Test that the representation of a Boolean object is formatted properly
"""
boolean = primitives.Boolean()
self.assertEqual("Boolean(value=True)", repr(boolean))
def test_init(self):
"""
Test that a Boolean object can be instantiated.
"""
boolean = primitives.Boolean(False)
self.assertEqual(False, boolean.value)
def test_str_default(self):
"""
Test that the string representation of a Boolean object is formatted
properly.
"""
self.assertEqual("True", str(primitives.Boolean()))
