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)