def test_not_equal_on_equal(self):
"""
Test that the inequality operator returns False when comparing two
Rekey request payloads with the same data.
"""
a = payloads.RekeyRequestPayload()
b = payloads.RekeyRequestPayload()
self.assertFalse(a != b)
self.assertFalse(b != a)
a = payloads.RekeyRequestPayload(
unique_identifier='1346d253-69d6-474c-8cd5-ad475a3e0a81',
offset=0,
template_attribute=objects.TemplateAttribute(attributes=[
objects.Attribute(
attribute_name=objects.Attribute.AttributeName(
'Activation Date'),
attribute_value=primitives.DateTime(
value=1136113200, tag=enums.Tags.ACTIVATION_DATE))
]))
b = payloads.RekeyRequestPayload(
unique_identifier='1346d253-69d6-474c-8cd5-ad475a3e0a81',
offset=0,
template_attribute=objects.TemplateAttribute(attributes=[
objects.Attribute(
attribute_name=objects.Attribute.AttributeName(
'Activation Date'),
attribute_value=primitives.DateTime(
value=1136113200, tag=enums.Tags.ACTIVATION_DATE))
]))
self.assertFalse(a != b)
self.assertFalse(b != a)
def test_read(self):
"""
Test that a Rekey request payload can be read from a data stream.
"""
payload = payloads.RekeyRequestPayload()
self.assertEqual(None, payload.unique_identifier)
self.assertEqual(None, payload.offset)
self.assertEqual(None, payload.template_attribute)
payload.read(self.full_encoding)
self.assertEqual(
'1346d253-69d6-474c-8cd5-ad475a3e0a81',
payload.unique_identifier
)
self.assertEqual(0, payload.offset)
self.assertEqual(
objects.TemplateAttribute(
attributes=[
objects.Attribute(
attribute_name=objects.Attribute.AttributeName(
'Activation Date'
),
attribute_value=primitives.DateTime(
value=1136113200,
tag=enums.Tags.ACTIVATION_DATE
)
),
objects.Attribute(
attribute_name=objects.Attribute.AttributeName(
'Process Start Date'
),
attribute_value=primitives.DateTime(
value=1136113200,
tag=enums.Tags.PROCESS_START_DATE
)
),
objects.Attribute(
attribute_name=objects.Attribute.AttributeName(
'Protect Stop Date'
),
attribute_value=primitives.DateTime(
value=1577876400,
tag=enums.Tags.PROTECT_STOP_DATE
)
),
objects.Attribute(
attribute_name=objects.Attribute.AttributeName(
'Deactivation Date'
),
attribute_value=primitives.DateTime(
value=1577876400,
tag=enums.Tags.DEACTIVATION_DATE
)
)
]
),
payload.template_attribute
)
def test_write(self):
"""
Test that a Rekey request payload can be written to a data stream.
"""
payload = payloads.RekeyRequestPayload(
unique_identifier='1346d253-69d6-474c-8cd5-ad475a3e0a81',
offset=0,
template_attribute=objects.TemplateAttribute(attributes=[
objects.Attribute(
attribute_name=objects.Attribute.AttributeName(
'Activation Date'),
attribute_value=primitives.DateTime(
value=1136113200, tag=enums.Tags.ACTIVATION_DATE)),
objects.Attribute(
attribute_name=objects.Attribute.AttributeName(
'Process Start Date'),
attribute_value=primitives.DateTime(
value=1136113200, tag=enums.Tags.PROCESS_START_DATE)),
objects.Attribute(
attribute_name=objects.Attribute.AttributeName(
'Protect Stop Date'),
attribute_value=primitives.DateTime(
value=1577876400, tag=enums.Tags.PROTECT_STOP_DATE)),
objects.Attribute(
attribute_name=objects.Attribute.AttributeName(
'Deactivation Date'),
attribute_value=primitives.DateTime(
value=1577876400, tag=enums.Tags.DEACTIVATION_DATE))
]))
stream = utils.BytearrayStream()
payload.write(stream)
self.assertEqual(len(self.full_encoding), len(stream))
self.assertEqual(str(self.full_encoding), str(stream))
def read(self, istream, kmip_version=enums.KMIPVersion.KMIP_1_0):
"""
Read the data encoding the RevokeRequestPayload object and decode it
into its constituent parts.
Args:
istream (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.
"""
super(RevokeRequestPayload, self).read(istream,
kmip_version=kmip_version)
tstream = BytearrayStream(istream.read(self.length))
self.unique_identifier = attributes.UniqueIdentifier()
self.unique_identifier.read(tstream, kmip_version=kmip_version)
self.revocation_reason = objects.RevocationReason()
self.revocation_reason.read(tstream, kmip_version=kmip_version)
if self.is_tag_next(enums.Tags.COMPROMISE_OCCURRENCE_DATE, tstream):
self.compromise_occurrence_date = primitives.DateTime(
tag=enums.Tags.COMPROMISE_OCCURRENCE_DATE)
self.compromise_occurrence_date.read(tstream,
kmip_version=kmip_version)
self.is_oversized(tstream)
self.validate()
def test_write_with_known_uuid(self):
"""
Test that a RevokeRequestPayload object with a known UUID can be
written to a data stream.
"""
reason = objects.RevocationReason(
code=enums.RevocationReasonCode.KEY_COMPROMISE)
date = primitives.DateTime(tag=enums.Tags.COMPROMISE_OCCURRENCE_DATE,
value=6)
stream = utils.BytearrayStream()
payload = payloads.RevokeRequestPayload(
unique_identifier=self.uuid,
revocation_reason=reason,
compromise_occurrence_date=date)
payload.write(stream)
length_expected = len(self.encoding_a)
length_received = len(stream)
msg = "encoding lengths not equal"
msg += "; expected {0}, received {1}".format(length_expected,
length_received)
self.assertEqual(length_expected, length_received, msg)
msg = "encoding mismatch"
msg += ";\nexpected:\n{0}\nreceived:\n{1}".format(
self.encoding_a, stream)
self.assertEqual(self.encoding_a, stream, msg)
def test_str(self):
"""
Test that str can be applied to a Rekey request payload
"""
payload = payloads.RekeyRequestPayload(
unique_identifier='49a1ca88-6bea-4fb2-b450-7e58802c3038',
offset=0,
template_attribute=objects.TemplateAttribute(
attributes=[
objects.Attribute(
attribute_name=objects.Attribute.AttributeName(
'Deactivation Date'
),
attribute_value=primitives.DateTime(
value=1577876400,
tag=enums.Tags.DEACTIVATION_DATE
)
)
]
)
)
# TODO (peter-hamilton) Update this when TemplateAttributes have str
expected = str({
'unique_identifier': '49a1ca88-6bea-4fb2-b450-7e58802c3038',
'offset': 0,
'template_attribute': 'Struct()'
})
observed = str(payload)
self.assertEqual(expected, observed)
def read(self, input_stream):
"""
Read the data encoding the ObtainLease response 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.
Raises:
ValueError: Raised if the data attribute is missing from the
encoded payload.
"""
super(ObtainLeaseResponsePayload, self).read(input_stream)
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)
if self.is_tag_next(enums.Tags.LEASE_TIME, local_stream):
self._lease_time = primitives.Interval(tag=enums.Tags.LEASE_TIME)
self._lease_time.read(local_stream)
if self.is_tag_next(enums.Tags.LAST_CHANGE_DATE, local_stream):
self._last_change_date = primitives.DateTime(
tag=enums.Tags.LAST_CHANGE_DATE)
self._last_change_date.read(local_stream)
self.is_oversized(local_stream)
def last_change_date(self, value):
if value is None:
self._last_change_date = None
elif isinstance(value, six.integer_types):
self._last_change_date = primitives.DateTime(
value=value, tag=enums.Tags.LAST_CHANGE_DATE)
else:
raise TypeError("Last change date must be an integer.")
def test_read(self):
"""
Test that a DateTime can be read from a byte stream.
"""
stream = utils.BytearrayStream(self.encoding)
date_time = primitives.DateTime()
date_time.read(stream)
self.assertEqual(self.value, date_time.value)
def test_str(self):
"""
Test that the string representation of a DateTime is formatted
properly.
"""
expected = 'Tue Aug 11 13:18:55 2015'
date_time = primitives.DateTime(1439299135)
self.assertEqual(expected, str(date_time))
def test_repr(self):
"""
Test that the representation of a DateTime is formatted properly.
"""
date_time = primitives.DateTime(1439299135)
value = "value={0}".format(date_time.value)
tag = "tag={0}".format(date_time.tag)
r = "DateTime({0}, {1})".format(value, tag)
self.assertEqual(r, repr(date_time))
def test_write(self):
"""
Test that a DateTime can be written to a byte stream.
"""
stream = utils.BytearrayStream()
date_time = primitives.DateTime(self.value)
date_time.write(stream)
result = stream.read()
self.assertEqual(len(self.encoding), len(result))
self.assertEqual(self.encoding, result)
def test_not_equal_on_not_equal_template_attribute(self):
"""
Test that the inequality operator returns True when comparing two Rekey
request payloads with different template attributes.
"""
a = payloads.RekeyRequestPayload(
template_attribute=objects.TemplateAttribute(
attributes=[
objects.Attribute(
attribute_name=objects.Attribute.AttributeName(
'Protect Stop Date'
),
attribute_value=primitives.DateTime(
value=1577876400,
tag=enums.Tags.PROTECT_STOP_DATE
)
)
]
)
)
b = payloads.RekeyRequestPayload(
template_attribute=objects.TemplateAttribute(
attributes=[
objects.Attribute(
attribute_name=objects.Attribute.AttributeName(
'Deactivation Date'
),
attribute_value=primitives.DateTime(
value=1577876400,
tag=enums.Tags.DEACTIVATION_DATE
)
)
]
)
)
self.assertTrue(a != b)
self.assertTrue(b != a)
def read(self, istream):
"""
Read the data encoding the RevokeRequestPayload object and decode it
into its constituent parts.
Args:
istream (Stream): A data stream containing encoded object data,
supporting a read method; usually a BytearrayStream object.
"""
super(RevokeRequestPayload, self).read(istream)
tstream = BytearrayStream(istream.read(self.length))
self.unique_identifier = attributes.UniqueIdentifier()
self.unique_identifier.read(tstream)
self.revocation_reason = objects.RevocationReason()
self.revocation_reason.read(tstream)
if self.is_tag_next(enums.Tags.COMPROMISE_OCCURRENCE_DATE, tstream):
self.compromise_date = primitives.DateTime(
tag=enums.Tags.COMPROMISE_OCCURRENCE_DATE)
self.compromise_date.read(tstream)
self.is_oversized(tstream)
self.validate()
def test_init(self):
"""
Test that a DateTime can be instantiated.
"""
date_time = primitives.DateTime(1)
self.assertEqual(1, date_time.value)
def revoke(self,
revocation_reason,
uid=None,
revocation_message=None,
compromise_occurrence_date=None):
"""
Revoke a managed object stored by a KMIP appliance.
Args:
revocation_reason (RevocationReasonCode): An enumeration indicating
the revocation reason.
uid (string): The unique ID of the managed object to revoke.
Optional, defaults to None.
revocation_message (string): A message regarding the revocation.
Optional, defaults to None.
compromise_occurrence_date (int): An integer, the number of seconds
since the epoch, which will be converted to the Datetime when
the managed object was first believed to be compromised.
Optional, defaults to None.
Returns:
None
Raises:
ClientConnectionNotOpen: if the client connection is unusable
KmipOperationFailure: if the operation result is a failure
TypeError: if the input argument is invalid
"""
# Check input
if not isinstance(revocation_reason, enums.RevocationReasonCode):
raise TypeError(
"revocation_reason must be a RevocationReasonCode enumeration")
if uid is not None:
if not isinstance(uid, six.string_types):
raise TypeError("uid must be a string")
if revocation_message is not None:
if not isinstance(revocation_message, six.string_types):
raise TypeError("revocation_message must be a string")
if compromise_occurrence_date is not None:
if not isinstance(compromise_occurrence_date, six.integer_types):
raise TypeError(
"compromise_occurrence_date must be an integer")
compromise_occurrence_date = primitives.DateTime(
compromise_occurrence_date, enums.Tags.COMPROMISE_OCCURRENCE_DATE)
# Verify that operations can be given at this time
if not self._is_open:
raise exceptions.ClientConnectionNotOpen()
# revoke the managed object and handle the results
result = self.proxy.revoke(revocation_reason, uid, revocation_message,
compromise_occurrence_date)
status = result.result_status.value
if status == enums.ResultStatus.SUCCESS:
return
else:
reason = result.result_reason.value
message = result.result_message.value
raise exceptions.KmipOperationFailure(status, reason, message)
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_init_unset(self):
"""
Test that a DateTime can be instantiated with no input.
"""
date_time = primitives.DateTime()
self.assertNotEqual(date_time.value, None)
