tyler.durden
/
PyKMIP
mirror of https://github.com/OpenKMIP/PyKMIP.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Update the CreateKeyPair payloads 

This change updates the CreateKeyPair payloads to the current
payload format, adding properties for different payload attributes
and adding comparison and string operators. Changes are also made
to the PyKMIP clients and the surrounding testing infrastructure
to reflect the payload changes. The official unit test suite for
the CreateKeyPair payloads has been updated to also reflect these
changes.

This change prepares the CreateKeyPair payloads for future
updates to support KMIP 2.0.
This commit is contained in:
Peter Hamilton 2019-03-13 18:34:21 -04:00 committed by Peter Hamilton
parent fe3095c22b
commit 71d508019a
12 changed files with 3767 additions and 646 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

645
kmip/core/messages/payloads/create_key_pair.py
View File

@ -13,243 +13,590 @@
# License for the specific language governing permissions and limitations
# under the License.
from kmip.core import attributes
from kmip.core import objects
import six
from kmip.core import enums
from kmip.core.primitives import Struct
from kmip.core.utils import BytearrayStream
from kmip.core import exceptions
from kmip.core import objects
from kmip.core import primitives
from kmip.core import utils
class CreateKeyPairRequestPayload(Struct):
class CreateKeyPairRequestPayload(primitives.Struct):
"""
A request payload for the CreateKeyPair operation.
Attributes:
common_template_attribute: A group of attributes to set on the new
public and private keys.
private_key_template_attribute: A group of attributes to set on the new
private key.
public_key_template_attribute: A group of attributes to set on the new
public key.
"""
def __init__(self,
common_template_attribute=None,
private_key_template_attribute=None,
public_key_template_attribute=None):
"""
Construct a CreateKeyPair request payload structure.
Args:
common_template_attribute (TemplateAttribute): A TemplateAttribute
structure with the CommonTemplateAttribute tag containing a set
of attributes to set on the new public and private keys.
Optional, defaults to None.
private_key_template_attribute (TemplateAttribute): A
TemplateAttribute structure with the
PrivateKeyTemplateAttribute tag containing a set of attributes
to set on the new private key. Optional, defaults to None.
public_key_template_attribute (TemplateAttribute): A
TemplateAttribute structure with the PublicKeyTemplateAttribute
tag containing a set of attributes to set on the new public
key. Optional, defaults to None.
"""
super(CreateKeyPairRequestPayload, self).__init__(
enums.Tags.REQUEST_PAYLOAD
)
self._common_template_attribute = None
self._private_key_template_attribute = None
self._public_key_template_attribute = None
self.common_template_attribute = common_template_attribute
self.private_key_template_attribute = private_key_template_attribute
self.public_key_template_attribute = public_key_template_attribute
self.validate()
@property
def common_template_attribute(self):
return self._common_template_attribute
def read(self, istream, kmip_version=enums.KMIPVersion.KMIP_1_0):
@common_template_attribute.setter
def common_template_attribute(self, value):
if value is None:
self._common_template_attribute = None
elif isinstance(value, objects.TemplateAttribute):
if value.tag == enums.Tags.COMMON_TEMPLATE_ATTRIBUTE:
self._common_template_attribute = value
else:
raise TypeError(
"Common template attribute must be a TemplateAttribute "
"structure with a CommonTemplateAttribute tag."
)
else:
raise TypeError(
"Common template attribute must be a TemplateAttribute "
"structure."
)
@property
def private_key_template_attribute(self):
return self._private_key_template_attribute
@private_key_template_attribute.setter
def private_key_template_attribute(self, value):
if value is None:
self._private_key_template_attribute = None
elif isinstance(value, objects.TemplateAttribute):
if value.tag == enums.Tags.PRIVATE_KEY_TEMPLATE_ATTRIBUTE:
self._private_key_template_attribute = value
else:
raise TypeError(
"Private key template attribute must be a "
"TemplateAttribute structure with a "
"PrivateKeyTemplateAttribute tag."
)
else:
raise TypeError(
"Private key template attribute must be a TemplateAttribute "
"structure."
)
@property
def public_key_template_attribute(self):
return self._public_key_template_attribute
@public_key_template_attribute.setter
def public_key_template_attribute(self, value):
if value is None:
self._public_key_template_attribute = None
elif isinstance(value, objects.TemplateAttribute):
if value.tag == enums.Tags.PUBLIC_KEY_TEMPLATE_ATTRIBUTE:
self._public_key_template_attribute = value
else:
raise TypeError(
"Public key template attribute must be a "
"TemplateAttribute structure with a "
"PublicKeyTemplateAttribute tag."
)
else:
raise TypeError(
"Public key template attribute must be a TemplateAttribute "
"structure."
)
def read(self, input_buffer, kmip_version=enums.KMIPVersion.KMIP_1_0):
"""
Read the data encoding the CreateKeyPair request payload and decode it
into its constituent parts.
Args:
input_buffer (stream): A data buffer containing encoded object
data, supporting a read method.
kmip_version (KMIPVersion): An enumeration defining the KMIP
version with which the object will be decoded. Optional,
defaults to KMIP 1.0.
"""
super(CreateKeyPairRequestPayload, self).read(
istream,
input_buffer,
kmip_version=kmip_version
)
tstream = BytearrayStream(istream.read(self.length))
local_buffer = utils.BytearrayStream(input_buffer.read(self.length))
if self.is_tag_next(enums.Tags.COMMON_TEMPLATE_ATTRIBUTE, tstream):
self.common_template_attribute = objects.CommonTemplateAttribute()
self.common_template_attribute.read(
tstream,
if self.is_tag_next(
enums.Tags.COMMON_TEMPLATE_ATTRIBUTE,
local_buffer
):
self._common_template_attribute = objects.TemplateAttribute(
tag=enums.Tags.COMMON_TEMPLATE_ATTRIBUTE
)
self._common_template_attribute.read(
local_buffer,
kmip_version=kmip_version
)
if self.is_tag_next(enums.Tags.PRIVATE_KEY_TEMPLATE_ATTRIBUTE,
tstream):
self.private_key_template_attribute = \
objects.PrivateKeyTemplateAttribute()
self.private_key_template_attribute.read(
tstream,
if self.is_tag_next(
enums.Tags.PRIVATE_KEY_TEMPLATE_ATTRIBUTE,
local_buffer
):
self._private_key_template_attribute = objects.TemplateAttribute(
tag=enums.Tags.PRIVATE_KEY_TEMPLATE_ATTRIBUTE
)
self._private_key_template_attribute.read(
local_buffer,
kmip_version=kmip_version
)
if self.is_tag_next(enums.Tags.PUBLIC_KEY_TEMPLATE_ATTRIBUTE, tstream):
self.public_key_template_attribute = \
objects.PublicKeyTemplateAttribute()
self.public_key_template_attribute.read(
tstream,
if self.is_tag_next(
enums.Tags.PUBLIC_KEY_TEMPLATE_ATTRIBUTE,
local_buffer
):
self._public_key_template_attribute = objects.TemplateAttribute(
tag=enums.Tags.PUBLIC_KEY_TEMPLATE_ATTRIBUTE
)
self._public_key_template_attribute.read(
local_buffer,
kmip_version=kmip_version
)
self.is_oversized(tstream)
self.validate()
self.is_oversized(local_buffer)
def write(self, ostream, kmip_version=enums.KMIPVersion.KMIP_1_0):
tstream = BytearrayStream()
def write(self, output_buffer, kmip_version=enums.KMIPVersion.KMIP_1_0):
"""
Write the data encoding the CreateKeyPair request payload to a buffer.
if self.common_template_attribute is not None:
self.common_template_attribute.write(
tstream,
Args:
output_buffer (stream): A data buffer in which to encode object
data, supporting a write method.
kmip_version (KMIPVersion): An enumeration defining the KMIP
version with which the object will be encoded. Optional,
defaults to KMIP 1.0.
"""
local_buffer = utils.BytearrayStream()
if self._common_template_attribute is not None:
self._common_template_attribute.write(
local_buffer,
kmip_version=kmip_version
)
if self.private_key_template_attribute is not None:
self.private_key_template_attribute.write(
tstream,
if self._private_key_template_attribute is not None:
self._private_key_template_attribute.write(
local_buffer,
kmip_version=kmip_version
)
if self.public_key_template_attribute is not None:
self.public_key_template_attribute.write(
tstream,
if self._public_key_template_attribute is not None:
self._public_key_template_attribute.write(
local_buffer,
kmip_version=kmip_version
)
self.length = tstream.length()
self.length = local_buffer.length()
super(CreateKeyPairRequestPayload, self).write(
ostream,
output_buffer,
kmip_version=kmip_version
)
ostream.write(tstream.buffer)
output_buffer.write(local_buffer.buffer)
def validate(self):
self.__validate()
def __eq__(self, other):
if isinstance(other, CreateKeyPairRequestPayload):
if self.common_template_attribute != \
other.common_template_attribute:
return False
elif self.private_key_template_attribute != \
other.private_key_template_attribute:
return False
elif self.public_key_template_attribute != \
other.public_key_template_attribute:
return False
else:
return True
else:
return NotImplemented
def __validate(self):
if self.common_template_attribute is not None:
if not isinstance(self.common_template_attribute,
objects.CommonTemplateAttribute):
msg = "invalid common template attribute"
msg += "; expected {0}, received {1}".format(
objects.CommonTemplateAttribute,
self.common_template_attribute)
raise TypeError(msg)
def __ne__(self, other):
if isinstance(other, CreateKeyPairRequestPayload):
return not (self == other)
else:
return NotImplemented
if self.private_key_template_attribute is not None:
if not isinstance(self.private_key_template_attribute,
objects.PrivateKeyTemplateAttribute):
msg = "invalid private key template attribute"
msg += "; expected {0}, received {1}".format(
objects.PrivateKeyTemplateAttribute,
self.private_key_template_attribute)
raise TypeError(msg)
def __repr__(self):
args = ", ".join([
"common_template_attribute={}".format(
self.common_template_attribute
),
"private_key_template_attribute={}".format(
self.private_key_template_attribute
),
"public_key_template_attribute={}".format(
self.public_key_template_attribute
)
])
return "CreateKeyPairRequestPayload({})".format(args)
if self.public_key_template_attribute is not None:
if not isinstance(self.public_key_template_attribute,
objects.PublicKeyTemplateAttribute):
msg = "invalid public key template attribute"
msg += "; expected {0}, received {1}".format(
objects.PublicKeyTemplateAttribute,
self.public_key_template_attribute)
raise TypeError(msg)
def __str__(self):
value = ", ".join(
[
'"common_template_attribute": {}'.format(
self.common_template_attribute
),
'"private_key_template_attribute": {}'.format(
self.private_key_template_attribute
),
'"public_key_template_attribute": {}'.format(
self.public_key_template_attribute
)
]
)
return '{' + value + '}'
class CreateKeyPairResponsePayload(Struct):
class CreateKeyPairResponsePayload(primitives.Struct):
"""
A response payload for the CreateKeyPair operation.
Attributes:
private_key_unique_identifier: The ID of the new private key.
public_key_unique_identifier: The ID of the new public key.
private_key_template_attribute: A group of attributes to set on the new
private key.
public_key_template_attribute: A group of attributes to set on the new
public key.
"""
def __init__(self,
private_key_uuid=None,
public_key_uuid=None,
private_key_unique_identifier=None,
public_key_unique_identifier=None,
private_key_template_attribute=None,
public_key_template_attribute=None):
super(CreateKeyPairResponsePayload, self).__init__(
enums.Tags.RESPONSE_PAYLOAD
)
# Private and public UUIDs are required so make defaults as backup
if private_key_uuid is None:
self.private_key_uuid = attributes.PrivateKeyUniqueIdentifier('')
else:
self.private_key_uuid = private_key_uuid
if public_key_uuid is None:
self.public_key_uuid = attributes.PublicKeyUniqueIdentifier('')
else:
self.public_key_uuid = public_key_uuid
self._private_key_unique_identifier = None
self._public_key_unique_identifier = None
self._private_key_template_attribute = None
self._public_key_template_attribute = None
self.private_key_unique_identifier = private_key_unique_identifier
self.public_key_unique_identifier = public_key_unique_identifier
self.private_key_template_attribute = private_key_template_attribute
self.public_key_template_attribute = public_key_template_attribute
self.validate()
@property
def private_key_unique_identifier(self):
if self._private_key_unique_identifier:
return self._private_key_unique_identifier.value
else:
return None
def read(self, istream, kmip_version=enums.KMIPVersion.KMIP_1_0):
@private_key_unique_identifier.setter
def private_key_unique_identifier(self, value):
if value is None:
self._private_key_unique_identifier = None
elif isinstance(value, six.string_types):
self._private_key_unique_identifier = primitives.TextString(
value=value,
tag=enums.Tags.PRIVATE_KEY_UNIQUE_IDENTIFIER
)
else:
raise TypeError("Private key unique identifier must be a string.")
@property
def public_key_unique_identifier(self):
if self._public_key_unique_identifier:
return self._public_key_unique_identifier.value
else:
return None
@public_key_unique_identifier.setter
def public_key_unique_identifier(self, value):
if value is None:
self._public_key_unique_identifier = None
elif isinstance(value, six.string_types):
self._public_key_unique_identifier = primitives.TextString(
value=value,
tag=enums.Tags.PUBLIC_KEY_UNIQUE_IDENTIFIER
)
else:
raise TypeError("Public key unique identifier must be a string.")
@property
def private_key_template_attribute(self):
return self._private_key_template_attribute
@private_key_template_attribute.setter
def private_key_template_attribute(self, value):
if value is None:
self._private_key_template_attribute = None
elif isinstance(value, objects.TemplateAttribute):
if value.tag == enums.Tags.PRIVATE_KEY_TEMPLATE_ATTRIBUTE:
self._private_key_template_attribute = value
else:
raise TypeError(
"Private key template attribute must be a "
"TemplateAttribute structure with a "
"PrivateKeyTemplateAttribute tag."
)
else:
raise TypeError(
"Private key template attribute must be a TemplateAttribute "
"structure."
)
@property
def public_key_template_attribute(self):
return self._public_key_template_attribute
@public_key_template_attribute.setter
def public_key_template_attribute(self, value):
if value is None:
self._public_key_template_attribute = None
elif isinstance(value, objects.TemplateAttribute):
if value.tag == enums.Tags.PUBLIC_KEY_TEMPLATE_ATTRIBUTE:
self._public_key_template_attribute = value
else:
raise TypeError(
"Public key template attribute must be a "
"TemplateAttribute structure with a "
"PublicKeyTemplateAttribute tag."
)
else:
raise TypeError(
"Public key template attribute must be a TemplateAttribute "
"structure."
)
def read(self, input_buffer, kmip_version=enums.KMIPVersion.KMIP_1_0):
"""
Read the data encoding the CreateKeyPair response payload and decode it
into its constituent parts.
Args:
input_buffer (stream): A data buffer containing encoded object
data, supporting a read method.
kmip_version (KMIPVersion): An enumeration defining the KMIP
version with which the object will be decoded. Optional,
defaults to KMIP 1.0.
Raises:
InvalidKmipEncoding: Raised if the private key unique identifier or
the public key unique identifier is missing from the encoded
payload.
"""
super(CreateKeyPairResponsePayload, self).read(
istream,
input_buffer,
kmip_version=kmip_version
)
tstream = BytearrayStream(istream.read(self.length))
local_buffer = utils.BytearrayStream(input_buffer.read(self.length))
self.private_key_uuid.read(tstream, kmip_version=kmip_version)
self.public_key_uuid.read(tstream, kmip_version=kmip_version)
if self.is_tag_next(
enums.Tags.PRIVATE_KEY_UNIQUE_IDENTIFIER,
local_buffer
):
self._private_key_unique_identifier = primitives.TextString(
tag=enums.Tags.PRIVATE_KEY_UNIQUE_IDENTIFIER
)
self._private_key_unique_identifier.read(
local_buffer,
kmip_version=kmip_version
)
else:
raise exceptions.InvalidKmipEncoding(
"The CreateKeyPair response payload encoding is missing the "
"private key unique identifier."
)
if self.is_tag_next(enums.Tags.PRIVATE_KEY_TEMPLATE_ATTRIBUTE,
tstream):
self.private_key_template_attribute = \
objects.PrivateKeyTemplateAttribute()
self.private_key_template_attribute.read(
tstream,
if self.is_tag_next(
enums.Tags.PUBLIC_KEY_UNIQUE_IDENTIFIER,
local_buffer
):
self._public_key_unique_identifier = primitives.TextString(
tag=enums.Tags.PUBLIC_KEY_UNIQUE_IDENTIFIER
)
self._public_key_unique_identifier.read(
local_buffer,
kmip_version=kmip_version
)
else:
raise exceptions.InvalidKmipEncoding(
"The CreateKeyPair response payload encoding is missing the "
"public key unique identifier."
)
if self.is_tag_next(
enums.Tags.PRIVATE_KEY_TEMPLATE_ATTRIBUTE,
local_buffer
):
self._private_key_template_attribute = objects.TemplateAttribute(
tag=enums.Tags.PRIVATE_KEY_TEMPLATE_ATTRIBUTE
)
self._private_key_template_attribute.read(
local_buffer,
kmip_version=kmip_version
)
if self.is_tag_next(enums.Tags.PUBLIC_KEY_TEMPLATE_ATTRIBUTE,
tstream):
self.public_key_template_attribute = \
objects.PublicKeyTemplateAttribute()
self.public_key_template_attribute.read(
tstream,
if self.is_tag_next(
enums.Tags.PUBLIC_KEY_TEMPLATE_ATTRIBUTE,
local_buffer
):
self._public_key_template_attribute = objects.TemplateAttribute(
tag=enums.Tags.PUBLIC_KEY_TEMPLATE_ATTRIBUTE
)
self._public_key_template_attribute.read(
local_buffer,
kmip_version=kmip_version
)
self.is_oversized(tstream)
self.validate()
self.is_oversized(local_buffer)
def write(self, ostream, kmip_version=enums.KMIPVersion.KMIP_1_0):
tstream = BytearrayStream()
def write(self, output_buffer, kmip_version=enums.KMIPVersion.KMIP_1_0):
"""
Write the data encoding the CreateKeyPair response payload to a buffer.
self.private_key_uuid.write(tstream, kmip_version=kmip_version)
self.public_key_uuid.write(tstream, kmip_version=kmip_version)
Args:
output_buffer (stream): A data buffer in which to encode object
data, supporting a write method.
kmip_version (KMIPVersion): An enumeration defining the KMIP
version with which the object will be encoded. Optional,
defaults to KMIP 1.0.
if self.private_key_template_attribute is not None:
self.private_key_template_attribute.write(
tstream,
Raises:
InvalidField: Raised if the private key unique identifier or the
public key unique identifier is not defined.
"""
local_buffer = utils.BytearrayStream()
if self._private_key_unique_identifier:
self._private_key_unique_identifier.write(
local_buffer,
kmip_version=kmip_version
)
else:
raise exceptions.InvalidField(
"The CreateKeyPair response payload is missing the private "
"key unique identifier field."
)
if self._public_key_unique_identifier:
self._public_key_unique_identifier.write(
local_buffer,
kmip_version=kmip_version
)
else:
raise exceptions.InvalidField(
"The CreateKeyPair response payload is missing the public "
"key unique identifier field."
)
if self._private_key_template_attribute:
self._private_key_template_attribute.write(
local_buffer,
kmip_version=kmip_version
)
if self.public_key_template_attribute is not None:
self.public_key_template_attribute.write(
tstream,
if self._public_key_template_attribute:
self._public_key_template_attribute.write(
local_buffer,
kmip_version=kmip_version
)
self.length = tstream.length()
self.length = local_buffer.length()
super(CreateKeyPairResponsePayload, self).write(
ostream,
output_buffer,
kmip_version=kmip_version
)
ostream.write(tstream.buffer)
output_buffer.write(local_buffer.buffer)
def validate(self):
self.__validate()
def __eq__(self, other):
if isinstance(other, CreateKeyPairResponsePayload):
if self.private_key_unique_identifier != \
other.private_key_unique_identifier:
return False
elif self.public_key_unique_identifier != \
other.public_key_unique_identifier:
return False
elif self.private_key_template_attribute != \
other.private_key_template_attribute:
return False
elif self.public_key_template_attribute != \
other.public_key_template_attribute:
return False
else:
return True
else:
return NotImplemented
def __validate(self):
if not isinstance(self.private_key_uuid,
attributes.PrivateKeyUniqueIdentifier):
msg = "invalid private key unique identifier"
msg += "; expected {0}, received {1}".format(
attributes.PrivateKeyUniqueIdentifier,
self.private_key_uuid)
raise TypeError(msg)
def __ne__(self, other):
if isinstance(other, CreateKeyPairResponsePayload):
return not (self == other)
else:
return NotImplemented
if not isinstance(self.public_key_uuid,
attributes.PublicKeyUniqueIdentifier):
msg = "invalid public key unique identifier"
msg += "; expected {0}, received {1}".format(
attributes.PublicKeyUniqueIdentifier,
self.public_key_uuid)
raise TypeError(msg)
def __repr__(self):
args = ", ".join([
"private_key_unique_identifier='{}'".format(
self.private_key_unique_identifier
),
"public_key_unique_identifier='{}'".format(
self.public_key_unique_identifier
),
"private_key_template_attribute={}".format(
self.private_key_template_attribute
),
"public_key_template_attribute={}".format(
self.public_key_template_attribute
)
])
return "CreateKeyPairResponsePayload({})".format(args)
if self.private_key_template_attribute is not None:
if not isinstance(self.private_key_template_attribute,
objects.PrivateKeyTemplateAttribute):
msg = "invalid private key template attribute"
msg += "; expected {0}, received {1}".format(
objects.PrivateKeyTemplateAttribute,
self.private_key_template_attribute)
raise TypeError(msg)
if self.public_key_template_attribute is not None:
if not isinstance(self.public_key_template_attribute,
objects.PublicKeyTemplateAttribute):
msg = "invalid public key template attribute"
msg += "; expected {0}, received {1}".format(
objects.PublicKeyTemplateAttribute,
self.public_key_template_attribute)
raise TypeError(msg)
def __str__(self):
value = ", ".join(
[
'"private_key_unique_identifier": "{}"'.format(
self.private_key_unique_identifier
),
'"public_key_unique_identifier": "{}"'.format(
self.public_key_unique_identifier
),
'"private_key_template_attribute": {}'.format(
self.private_key_template_attribute
),
'"public_key_template_attribute": {}'.format(
self.public_key_template_attribute
)
]
)
return '{' + value + '}'

1
kmip/core/messages/payloads/rekey_key_pair.py
View File

@ -168,6 +168,7 @@ class RekeyKeyPairRequestPayload(Struct):
raise TypeError(msg)
# TODO (ph) Remove the dependency on the CreateKeyPairResponsePayload
class RekeyKeyPairResponsePayload(CreateKeyPairResponsePayload):
def __init__(self,

4
kmip/demos/pie/create_key_pair.py
View File

@ -51,7 +51,9 @@ if __name__ == '__main__':
public_uid, private_uid = client.create_key_pair(
algorithm,
length,
operation_policy_name=opts.operation_policy_name
operation_policy_name=opts.operation_policy_name,
public_usage_mask=[enums.CryptographicUsageMask.VERIFY],
private_usage_mask=[enums.CryptographicUsageMask.SIGN]
)
logger.info("Successfully created public key with ID: {0}".format(
public_uid))

27
kmip/demos/units/create_key_pair.py
View File

@ -30,9 +30,7 @@ from kmip.core.factories.credentials import CredentialFactory
from kmip.core.attributes import Name
from kmip.core.attributes import CryptographicUsageMask
from kmip.core.objects import CommonTemplateAttribute
from kmip.core.objects import PrivateKeyTemplateAttribute
from kmip.core.objects import PublicKeyTemplateAttribute
from kmip.core.objects import TemplateAttribute
from kmip.core.objects import Attribute
from kmip.services.kmip_client import KMIPProxy
@ -117,14 +115,25 @@ if __name__ == '__main__':
)
attributes.append(opn)
common = CommonTemplateAttribute(attributes=attributes)
private = PrivateKeyTemplateAttribute(attributes=attributes)
public = PublicKeyTemplateAttribute(attributes=attributes)
common = TemplateAttribute(
attributes=attributes,
tag=enums.Tags.COMMON_TEMPLATE_ATTRIBUTE
)
private = TemplateAttribute(
attributes=attributes,
tag=enums.Tags.PRIVATE_KEY_TEMPLATE_ATTRIBUTE
)
public = TemplateAttribute(
attributes=attributes,
tag=enums.Tags.PUBLIC_KEY_TEMPLATE_ATTRIBUTE
)
# Create the SYMMETRIC_KEY object
result = client.create_key_pair(common_template_attribute=common,
private_key_template_attribute=private,
public_key_template_attribute=public)
result = client.create_key_pair(
common_template_attribute=common,
private_key_template_attribute=private,
public_key_template_attribute=public
)
client.close()
# Display operation results

19
kmip/pie/client.py
View File

@ -313,8 +313,9 @@ class ProxyKmipClient(object):
)
common_attributes.extend([algorithm_attribute, length_attribute])
template = cobjects.CommonTemplateAttribute(
attributes=common_attributes
template = cobjects.TemplateAttribute(
attributes=common_attributes,
tag=enums.Tags.COMMON_TEMPLATE_ATTRIBUTE
)
# Create public / private specific attributes
@ -331,9 +332,10 @@ class ProxyKmipClient(object):
)
]
if names or attrs:
public_template = cobjects.PublicKeyTemplateAttribute(
public_template = cobjects.TemplateAttribute(
names=names,
attributes=attrs
attributes=attrs,
tag=enums.Tags.PUBLIC_KEY_TEMPLATE_ATTRIBUTE
)
private_template = None
@ -349,9 +351,10 @@ class ProxyKmipClient(object):
)
]
if names or attrs:
private_template = cobjects.PrivateKeyTemplateAttribute(
private_template = cobjects.TemplateAttribute(
names=names,
attributes=attrs
attributes=attrs,
tag=enums.Tags.PRIVATE_KEY_TEMPLATE_ATTRIBUTE
)
# Create the asymmetric key pair and handle the results
@ -362,8 +365,8 @@ class ProxyKmipClient(object):
status = result.result_status.value
if status == enums.ResultStatus.SUCCESS:
public_uid = result.public_key_uuid.value
private_uid = result.private_key_uuid.value
public_uid = result.public_key_uuid
private_uid = result.private_key_uuid
return public_uid, private_uid
else:
reason = result.result_reason.value

4
kmip/services/kmip_client.py
View File

@ -1222,8 +1222,8 @@ class KMIPProxy(object):
payload_public_key_template_attribute = None
if payload is not None:
payload_private_key_uuid = payload.private_key_uuid
payload_public_key_uuid = payload.public_key_uuid
payload_private_key_uuid = payload.private_key_unique_identifier
payload_public_key_uuid = payload.public_key_unique_identifier
payload_private_key_template_attribute = \
payload.private_key_template_attribute
payload_public_key_template_attribute = \

8
kmip/services/server/engine.py
View File

@ -1270,12 +1270,8 @@ class KmipEngine(object):
)
response_payload = payloads.CreateKeyPairResponsePayload(
private_key_uuid=attributes.PrivateKeyUniqueIdentifier(
str(private_key.unique_identifier)
),
public_key_uuid=attributes.PublicKeyUniqueIdentifier(
str(public_key.unique_identifier)
)
private_key_unique_identifier=str(private_key.unique_identifier),
public_key_unique_identifier=str(public_key.unique_identifier)
)
self._id_placeholder = str(private_key.unique_identifier)

37
kmip/tests/integration/services/test_integration.py
View File

@ -20,6 +20,7 @@ from kmip.core.attributes import CryptographicAlgorithm
from kmip.core.attributes import CryptographicLength
from kmip.core.attributes import Name
from kmip.core import enums
from kmip.core.enums import AttributeType
from kmip.core.enums import CryptographicAlgorithm as CryptoAlgorithmEnum
from kmip.core.enums import CryptographicUsageMask
@ -44,9 +45,6 @@ from kmip.core.objects import KeyBlock
from kmip.core.objects import KeyMaterial
from kmip.core.objects import KeyValue
from kmip.core.objects import TemplateAttribute
from kmip.core.objects import PrivateKeyTemplateAttribute
from kmip.core.objects import PublicKeyTemplateAttribute
from kmip.core.objects import CommonTemplateAttribute
from kmip.core.misc import QueryFunction
@ -149,11 +147,18 @@ class TestIntegration(TestCase):
private_key_attributes = [priv_name]
public_key_attributes = [pub_name]
common = CommonTemplateAttribute(attributes=common_attributes)
priv_templ_attr = PrivateKeyTemplateAttribute(
attributes=private_key_attributes)
pub_templ_attr = PublicKeyTemplateAttribute(
attributes=public_key_attributes)
common = TemplateAttribute(
attributes=common_attributes,
tag=enums.Tags.COMMON_TEMPLATE_ATTRIBUTE
)
priv_templ_attr = TemplateAttribute(
attributes=private_key_attributes,
tag=enums.Tags.PRIVATE_KEY_TEMPLATE_ATTRIBUTE
)
pub_templ_attr = TemplateAttribute(
attributes=public_key_attributes,
tag=enums.Tags.PUBLIC_KEY_TEMPLATE_ATTRIBUTE
)
return self.client.\
create_key_pair(common_template_attribute=common,
@ -488,12 +493,12 @@ class TestIntegration(TestCase):
self._check_result_status(result, ResultStatus, ResultStatus.SUCCESS)
# Check UUID value for Private key
self._check_uuid(result.private_key_uuid.value, str)
self._check_uuid(result.private_key_uuid, str)
# Check UUID value for Public key
self._check_uuid(result.public_key_uuid.value, str)
self._check_uuid(result.public_key_uuid, str)
priv_key_uuid = result.private_key_uuid.value
pub_key_uuid = result.public_key_uuid.value
priv_key_uuid = result.private_key_uuid
pub_key_uuid = result.public_key_uuid
priv_key_result = self.client.get(uuid=priv_key_uuid, credential=None)
pub_key_result = self.client.get(uuid=pub_key_uuid, credential=None)
@ -522,17 +527,17 @@ class TestIntegration(TestCase):
self.assertIsInstance(pub_secret, pub_expected)
self.logger.debug('Destroying key: ' + key_name + ' Private' +
'\n With UUID: ' + result.private_key_uuid.value)
'\n With UUID: ' + result.private_key_uuid)
destroy_priv_key_result = self.client.destroy(
result.private_key_uuid.value)
result.private_key_uuid)
self._check_result_status(destroy_priv_key_result, ResultStatus,
ResultStatus.SUCCESS)
self.logger.debug('Destroying key: ' + key_name + ' Public' +
'\n With UUID: ' + result.public_key_uuid.value)
'\n With UUID: ' + result.public_key_uuid)
destroy_pub_key_result = self.client.destroy(
result.public_key_uuid.value)
result.public_key_uuid)
self._check_result_status(destroy_pub_key_result, ResultStatus,
ResultStatus.SUCCESS)

3268
kmip/tests/unit/core/messages/payloads/test_create_key_pair.py
View File

File diff suppressed because it is too large Load Diff

138
kmip/tests/unit/core/messages/payloads/test_rekey_key_pair.py
View File

@ -187,24 +187,12 @@ class TestRekeyKeyPairRequestPayload(TestCase):
self._test_write(stream, payload, self.encoding_full)
# TODO (ph) Replicate CreateKeyPairResponsePayload test suite here
class TestRekeyKeyPairResponsePayload(TestCase):
def setUp(self):
super(TestRekeyKeyPairResponsePayload, self).setUp()
self.uuid = '00000000-0000-0000-0000-000000000000'
self.private_key_uuid = attributes.PrivateKeyUniqueIdentifier(
self.uuid)
self.public_key_uuid = attributes.PublicKeyUniqueIdentifier(
self.uuid)
self.empty_private_key_uuid = attributes.PrivateKeyUniqueIdentifier('')
self.empty_public_key_uuid = attributes.PublicKeyUniqueIdentifier('')
self.private_key_template_attribute = \
objects.PrivateKeyTemplateAttribute()
self.public_key_template_attribute = \
objects.PublicKeyTemplateAttribute()
self.encoding_empty = utils.BytearrayStream((
b'\x42\x00\x7C\x01\x00\x00\x00\x10\x42\x00\x66\x07\x00\x00\x00\x00'
b'\x42\x00\x6F\x07\x00\x00\x00\x00'))
@ -220,127 +208,3 @@ class TestRekeyKeyPairResponsePayload(TestCase):
def tearDown(self):
super(TestRekeyKeyPairResponsePayload, self).tearDown()
def test_init_with_none(self):
payloads.RekeyKeyPairResponsePayload()
def test_init_with_args(self):
payloads.RekeyKeyPairResponsePayload(
self.private_key_uuid, self.public_key_uuid,
self.private_key_template_attribute,
self.public_key_template_attribute)
def test_validate_with_invalid_private_key_unique_identifier(self):
kwargs = {'private_key_uuid': 'invalid',
'public_key_uuid': None,
'private_key_template_attribute': None,
'public_key_template_attribute': None}
self.assertRaisesRegex(
TypeError, "invalid private key unique identifier",
payloads.RekeyKeyPairResponsePayload, **kwargs)
def test_validate_with_invalid_public_key_unique_identifier(self):
kwargs = {'private_key_uuid': None,
'public_key_uuid': 'invalid',
'private_key_template_attribute': None,
'public_key_template_attribute': None}
self.assertRaisesRegex(
TypeError, "invalid public key unique identifier",
payloads.RekeyKeyPairResponsePayload, **kwargs)
def test_validate_with_invalid_private_key_template_attribute(self):
kwargs = {'private_key_uuid': None,
'public_key_uuid': None,
'private_key_template_attribute': 'invalid',
'public_key_template_attribute': None}
self.assertRaisesRegex(
TypeError, "invalid private key template attribute",
payloads.RekeyKeyPairResponsePayload, **kwargs)
def test_validate_with_invalid_public_key_template_attribute(self):
kwargs = {'private_key_uuid': None,
'public_key_uuid': None,
'private_key_template_attribute': None,
'public_key_template_attribute': 'invalid'}
self.assertRaisesRegex(
TypeError, "invalid public key template attribute",
payloads.RekeyKeyPairResponsePayload, **kwargs)
def _test_read(self, stream, payload, private_key_uuid, public_key_uuid,
private_key_template_attribute,
public_key_template_attribute):
payload.read(stream)
msg = "private_key_uuid decoding mismatch"
msg += "; expected {0}, received {1}".format(
private_key_uuid, payload.private_key_uuid)
self.assertEqual(private_key_uuid, payload.private_key_uuid, msg)
msg = "public_key_uuid decoding mismatch"
msg += "; expected {0}, received {1}".format(
public_key_uuid, payload.public_key_uuid)
self.assertEqual(public_key_uuid, payload.public_key_uuid, msg)
msg = "private_key_template_attribute decoding mismatch"
msg += "; expected {0}, received {1}".format(
private_key_template_attribute,
payload.private_key_template_attribute)
self.assertEqual(private_key_template_attribute,
payload.private_key_template_attribute, msg)
msg = "public_key_template_attribute decoding mismatch"
msg += "; expected {0}, received {1}".format(
public_key_template_attribute,
payload.public_key_template_attribute)
self.assertEqual(public_key_template_attribute,
payload.public_key_template_attribute, msg)
def test_read_with_none(self):
stream = self.encoding_empty
payload = payloads.RekeyKeyPairResponsePayload()
self._test_read(stream, payload, self.empty_private_key_uuid,
self.empty_public_key_uuid, None, None)
def test_read_with_args(self):
stream = self.encoding_full
payload = payloads.RekeyKeyPairResponsePayload(
self.private_key_uuid, self.public_key_uuid,
self.private_key_template_attribute,
self.public_key_template_attribute)
self._test_read(stream, payload, self.private_key_uuid,
self.public_key_uuid,
self.private_key_template_attribute,
self.public_key_template_attribute)
def _test_write(self, stream, payload, expected):
payload.write(stream)
length_expected = len(expected)
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(expected, stream)
self.assertEqual(expected, stream, msg)
def test_write_with_none(self):
stream = utils.BytearrayStream()
payload = payloads.RekeyKeyPairResponsePayload()
self._test_write(stream, payload, self.encoding_empty)
def test_write_with_args(self):
stream = utils.BytearrayStream()
payload = payloads.RekeyKeyPairResponsePayload(
self.private_key_uuid, self.public_key_uuid,
self.private_key_template_attribute,
self.public_key_template_attribute)
self._test_write(stream, payload, self.encoding_full)

104
kmip/tests/unit/pie/test_client.py
View File

@ -483,15 +483,17 @@ class TestProxyKmipClient(testtools.TestCase):
enums.AttributeType.CRYPTOGRAPHIC_LENGTH, length)
attributes = [algorithm_attribute, length_attribute]
template = obj.CommonTemplateAttribute(attributes=attributes)
template = obj.TemplateAttribute(
attributes=attributes,
tag=enums.Tags.COMMON_TEMPLATE_ATTRIBUTE
)
status = enums.ResultStatus.SUCCESS
result = results.CreateKeyPairResult(
contents.ResultStatus(status),
public_key_uuid=attr.PublicKeyUniqueIdentifier(
'aaaaaaaa-1111-2222-3333-ffffffffffff'),
private_key_uuid=attr.PrivateKeyUniqueIdentifier(
'ffffffff-3333-2222-1111-aaaaaaaaaaaa'))
public_key_uuid="aaaaaaaa-1111-2222-3333-ffffffffffff",
private_key_uuid="ffffffff-3333-2222-1111-aaaaaaaaaaaa"
)
with ProxyKmipClient() as client:
client.proxy.create_key_pair.return_value = result
@ -501,9 +503,11 @@ class TestProxyKmipClient(testtools.TestCase):
2048
)
kwargs = {'common_template_attribute': template,
'private_key_template_attribute': None,
'public_key_template_attribute': None}
kwargs = {
"common_template_attribute": template,
"private_key_template_attribute": None,
"public_key_template_attribute": None
}
client.proxy.create_key_pair.assert_called_with(**kwargs)
self.assertIsInstance(public_uid, six.string_types)
self.assertIsInstance(private_uid, six.string_types)
@ -533,15 +537,17 @@ class TestProxyKmipClient(testtools.TestCase):
algorithm_attribute,
length_attribute
]
template = obj.CommonTemplateAttribute(attributes=pair_attributes)
template = obj.TemplateAttribute(
attributes=pair_attributes,
tag=enums.Tags.COMMON_TEMPLATE_ATTRIBUTE
)
status = enums.ResultStatus.SUCCESS
result = results.CreateKeyPairResult(
contents.ResultStatus(status),
public_key_uuid=attr.PublicKeyUniqueIdentifier(
'aaaaaaaa-1111-2222-3333-ffffffffffff'),
private_key_uuid=attr.PrivateKeyUniqueIdentifier(
'ffffffff-3333-2222-1111-aaaaaaaaaaaa'))
public_key_uuid="aaaaaaaa-1111-2222-3333-ffffffffffff",
private_key_uuid="ffffffff-3333-2222-1111-aaaaaaaaaaaa"
)
with ProxyKmipClient() as client:
client.proxy.create_key_pair.return_value = result
@ -552,9 +558,11 @@ class TestProxyKmipClient(testtools.TestCase):
operation_policy_name='test'
)
kwargs = {'common_template_attribute': template,
'private_key_template_attribute': None,
'public_key_template_attribute': None}
kwargs = {
"common_template_attribute": template,
"private_key_template_attribute": None,
"public_key_template_attribute": None
}
client.proxy.create_key_pair.assert_called_with(**kwargs)
@mock.patch('kmip.pie.client.KMIPProxy',
@ -583,19 +591,25 @@ class TestProxyKmipClient(testtools.TestCase):
length_attribute
]
template = obj.CommonTemplateAttribute(attributes=pair_attributes)
private_template = obj.PrivateKeyTemplateAttribute(
names=[private_name_attribute])
public_template = obj.PublicKeyTemplateAttribute(
names=[public_name_attribute])
template = obj.TemplateAttribute(
attributes=pair_attributes,
tag=enums.Tags.COMMON_TEMPLATE_ATTRIBUTE
)
private_template = obj.TemplateAttribute(
names=[private_name_attribute],
tag=enums.Tags.PRIVATE_KEY_TEMPLATE_ATTRIBUTE
)
public_template = obj.TemplateAttribute(
names=[public_name_attribute],
tag=enums.Tags.PUBLIC_KEY_TEMPLATE_ATTRIBUTE
)
status = enums.ResultStatus.SUCCESS
result = results.CreateKeyPairResult(
contents.ResultStatus(status),
public_key_uuid=attr.PublicKeyUniqueIdentifier(
'aaaaaaaa-1111-2222-3333-ffffffffffff'),
private_key_uuid=attr.PrivateKeyUniqueIdentifier(
'ffffffff-3333-2222-1111-aaaaaaaaaaaa'))
public_key_uuid="aaaaaaaa-1111-2222-3333-ffffffffffff",
private_key_uuid="ffffffff-3333-2222-1111-aaaaaaaaaaaa"
)
with ProxyKmipClient() as client:
client.proxy.create_key_pair.return_value = result
@ -607,9 +621,11 @@ class TestProxyKmipClient(testtools.TestCase):
private_name="private"
)
kwargs = {'common_template_attribute': template,
'private_key_template_attribute': private_template,
'public_key_template_attribute': public_template}
kwargs = {
"common_template_attribute": template,
"private_key_template_attribute": private_template,
"public_key_template_attribute": public_template
}
client.proxy.create_key_pair.assert_called_with(**kwargs)
@mock.patch('kmip.pie.client.KMIPProxy',
@ -642,19 +658,25 @@ class TestProxyKmipClient(testtools.TestCase):
length_attribute
]
template = obj.CommonTemplateAttribute(attributes=pair_attributes)
private_template = obj.PrivateKeyTemplateAttribute(
attributes=[private_usage_mask])
public_template = obj.PublicKeyTemplateAttribute(
attributes=[public_usage_mask])
template = obj.TemplateAttribute(
attributes=pair_attributes,
tag=enums.Tags.COMMON_TEMPLATE_ATTRIBUTE
)
private_template = obj.TemplateAttribute(
attributes=[private_usage_mask],
tag=enums.Tags.PRIVATE_KEY_TEMPLATE_ATTRIBUTE
)
public_template = obj.TemplateAttribute(
attributes=[public_usage_mask],
tag=enums.Tags.PUBLIC_KEY_TEMPLATE_ATTRIBUTE
)
status = enums.ResultStatus.SUCCESS
result = results.CreateKeyPairResult(
contents.ResultStatus(status),
public_key_uuid=attr.PublicKeyUniqueIdentifier(
'aaaaaaaa-1111-2222-3333-ffffffffffff'),
private_key_uuid=attr.PrivateKeyUniqueIdentifier(
'ffffffff-3333-2222-1111-aaaaaaaaaaaa'))
public_key_uuid="aaaaaaaa-1111-2222-3333-ffffffffffff",
private_key_uuid="ffffffff-3333-2222-1111-aaaaaaaaaaaa"
)
with ProxyKmipClient() as client:
client.proxy.create_key_pair.return_value = result
@ -666,9 +688,11 @@ class TestProxyKmipClient(testtools.TestCase):
private_usage_mask=[enums.CryptographicUsageMask.SIGN]
)
kwargs = {'common_template_attribute': template,
'private_key_template_attribute': private_template,
'public_key_template_attribute': public_template}
kwargs = {
"common_template_attribute": template,
"private_key_template_attribute": private_template,
"public_key_template_attribute": public_template
}
client.proxy.create_key_pair.assert_called_with(**kwargs)
@mock.patch('kmip.pie.client.KMIPProxy',

158
kmip/tests/unit/services/server/test_engine.py
View File

@ -2666,7 +2666,7 @@ class TestKmipEngine(testtools.TestCase):
attribute_factory = factory.AttributeFactory()
common_template = objects.CommonTemplateAttribute(
common_template = objects.TemplateAttribute(
attributes=[
attribute_factory.create_attribute(
enums.AttributeType.NAME,
@ -2683,9 +2683,10 @@ class TestKmipEngine(testtools.TestCase):
enums.AttributeType.CRYPTOGRAPHIC_LENGTH,
2048
)
]
],
tag=enums.Tags.COMMON_TEMPLATE_ATTRIBUTE
)
public_template = objects.PublicKeyTemplateAttribute(
public_template = objects.TemplateAttribute(
attributes=[
attribute_factory.create_attribute(
enums.AttributeType.CRYPTOGRAPHIC_USAGE_MASK,
@ -2693,9 +2694,10 @@ class TestKmipEngine(testtools.TestCase):
enums.CryptographicUsageMask.ENCRYPT
]
)
]
],
tag=enums.Tags.PUBLIC_KEY_TEMPLATE_ATTRIBUTE
)
private_template = objects.PrivateKeyTemplateAttribute(
private_template = objects.TemplateAttribute(
attributes=[
attribute_factory.create_attribute(
enums.AttributeType.CRYPTOGRAPHIC_USAGE_MASK,
@ -2703,7 +2705,8 @@ class TestKmipEngine(testtools.TestCase):
enums.CryptographicUsageMask.DECRYPT
]
)
]
],
tag=enums.Tags.PRIVATE_KEY_TEMPLATE_ATTRIBUTE
)
payload = payloads.CreateKeyPairRequestPayload(
common_template,
@ -2719,9 +2722,9 @@ class TestKmipEngine(testtools.TestCase):
"Processing operation: CreateKeyPair"
)
public_id = response_payload.public_key_uuid.value
public_id = response_payload.public_key_unique_identifier
self.assertEqual('1', public_id)
private_id = response_payload.private_key_uuid.value
private_id = response_payload.private_key_unique_identifier
self.assertEqual('2', private_id)
# Retrieve the stored public key and verify all attributes were set
@ -2794,7 +2797,7 @@ class TestKmipEngine(testtools.TestCase):
attribute_factory = factory.AttributeFactory()
# Test that a missing PublicKey CryptographicAlgorithm raises an error
common_template = objects.CommonTemplateAttribute(
common_template = objects.TemplateAttribute(
attributes=[
attribute_factory.create_attribute(
enums.AttributeType.NAME,
@ -2803,9 +2806,10 @@ class TestKmipEngine(testtools.TestCase):
enums.NameType.UNINTERPRETED_TEXT_STRING
)
)
]
],
tag=enums.Tags.COMMON_TEMPLATE_ATTRIBUTE
)
public_template = objects.PublicKeyTemplateAttribute(
public_template = objects.TemplateAttribute(
attributes=[
attribute_factory.create_attribute(
enums.AttributeType.CRYPTOGRAPHIC_LENGTH,
@ -2817,9 +2821,10 @@ class TestKmipEngine(testtools.TestCase):
enums.CryptographicUsageMask.ENCRYPT
]
)
]
],
tag=enums.Tags.PUBLIC_KEY_TEMPLATE_ATTRIBUTE
)
private_template = objects.PrivateKeyTemplateAttribute(
private_template = objects.TemplateAttribute(
attributes=[
attribute_factory.create_attribute(
enums.AttributeType.CRYPTOGRAPHIC_ALGORITHM,
@ -2835,7 +2840,8 @@ class TestKmipEngine(testtools.TestCase):
enums.CryptographicUsageMask.DECRYPT
]
)
]
],
tag=enums.Tags.PRIVATE_KEY_TEMPLATE_ATTRIBUTE
)
payload = payloads.CreateKeyPairRequestPayload(
common_template,
@ -2861,7 +2867,7 @@ class TestKmipEngine(testtools.TestCase):
e._logger.reset_mock()
# Test that a missing PrivateKey CryptographicAlgorithm raises an error
common_template = objects.CommonTemplateAttribute(
common_template = objects.TemplateAttribute(
attributes=[
attribute_factory.create_attribute(
enums.AttributeType.NAME,
@ -2870,9 +2876,10 @@ class TestKmipEngine(testtools.TestCase):
enums.NameType.UNINTERPRETED_TEXT_STRING
)
)
]
],
tag=enums.Tags.COMMON_TEMPLATE_ATTRIBUTE
)
public_template = objects.PublicKeyTemplateAttribute(
public_template = objects.TemplateAttribute(
attributes=[
attribute_factory.create_attribute(
enums.AttributeType.CRYPTOGRAPHIC_ALGORITHM,
@ -2888,9 +2895,10 @@ class TestKmipEngine(testtools.TestCase):
enums.CryptographicUsageMask.ENCRYPT
]
)
]
],
tag=enums.Tags.PUBLIC_KEY_TEMPLATE_ATTRIBUTE
)
private_template = objects.PrivateKeyTemplateAttribute(
private_template = objects.TemplateAttribute(
attributes=[
attribute_factory.create_attribute(
enums.AttributeType.CRYPTOGRAPHIC_LENGTH,
@ -2902,7 +2910,8 @@ class TestKmipEngine(testtools.TestCase):
enums.CryptographicUsageMask.DECRYPT
]
)
]
],
tag=enums.Tags.PRIVATE_KEY_TEMPLATE_ATTRIBUTE
)
payload = payloads.CreateKeyPairRequestPayload(
common_template,
@ -2928,7 +2937,7 @@ class TestKmipEngine(testtools.TestCase):
e._logger.reset_mock()
# Test that a missing PublicKey CryptographicLength raises an error
common_template = objects.CommonTemplateAttribute(
common_template = objects.TemplateAttribute(
attributes=[
attribute_factory.create_attribute(
enums.AttributeType.NAME,
@ -2937,9 +2946,10 @@ class TestKmipEngine(testtools.TestCase):
enums.NameType.UNINTERPRETED_TEXT_STRING
)
)
]
],
tag=enums.Tags.COMMON_TEMPLATE_ATTRIBUTE
)
public_template = objects.PublicKeyTemplateAttribute(
public_template = objects.TemplateAttribute(
attributes=[
attribute_factory.create_attribute(
enums.AttributeType.CRYPTOGRAPHIC_ALGORITHM,
@ -2951,9 +2961,10 @@ class TestKmipEngine(testtools.TestCase):
enums.CryptographicUsageMask.ENCRYPT
]
)
]
],
tag=enums.Tags.PUBLIC_KEY_TEMPLATE_ATTRIBUTE
)
private_template = objects.PrivateKeyTemplateAttribute(
private_template = objects.TemplateAttribute(
attributes=[
attribute_factory.create_attribute(
enums.AttributeType.CRYPTOGRAPHIC_ALGORITHM,
@ -2969,7 +2980,8 @@ class TestKmipEngine(testtools.TestCase):
enums.CryptographicUsageMask.DECRYPT
]
)
]
],
tag=enums.Tags.PRIVATE_KEY_TEMPLATE_ATTRIBUTE
)
payload = payloads.CreateKeyPairRequestPayload(
common_template,
@ -2995,7 +3007,7 @@ class TestKmipEngine(testtools.TestCase):
e._logger.reset_mock()
# Test that a missing PrivateKey CryptographicLength raises an error
common_template = objects.CommonTemplateAttribute(
common_template = objects.TemplateAttribute(
attributes=[
attribute_factory.create_attribute(
enums.AttributeType.NAME,
@ -3004,9 +3016,10 @@ class TestKmipEngine(testtools.TestCase):
enums.NameType.UNINTERPRETED_TEXT_STRING
)
)
]
],
tag=enums.Tags.COMMON_TEMPLATE_ATTRIBUTE
)
public_template = objects.PublicKeyTemplateAttribute(
public_template = objects.TemplateAttribute(
attributes=[
attribute_factory.create_attribute(
enums.AttributeType.CRYPTOGRAPHIC_ALGORITHM,
@ -3022,9 +3035,10 @@ class TestKmipEngine(testtools.TestCase):
enums.CryptographicUsageMask.ENCRYPT
]
)
]
],
tag=enums.Tags.PUBLIC_KEY_TEMPLATE_ATTRIBUTE
)
private_template = objects.PrivateKeyTemplateAttribute(
private_template = objects.TemplateAttribute(
attributes=[
attribute_factory.create_attribute(
enums.AttributeType.CRYPTOGRAPHIC_ALGORITHM,
@ -3036,7 +3050,8 @@ class TestKmipEngine(testtools.TestCase):
enums.CryptographicUsageMask.DECRYPT
]
)
]
],
tag=enums.Tags.PRIVATE_KEY_TEMPLATE_ATTRIBUTE
)
payload = payloads.CreateKeyPairRequestPayload(
common_template,
@ -3062,7 +3077,7 @@ class TestKmipEngine(testtools.TestCase):
e._logger.reset_mock()
# Test that a missing PublicKey CryptographicUsageMask raises an error
common_template = objects.CommonTemplateAttribute(
common_template = objects.TemplateAttribute(
attributes=[
attribute_factory.create_attribute(
enums.AttributeType.NAME,
@ -3071,9 +3086,10 @@ class TestKmipEngine(testtools.TestCase):
enums.NameType.UNINTERPRETED_TEXT_STRING
)
)
]
],
tag=enums.Tags.COMMON_TEMPLATE_ATTRIBUTE
)
public_template = objects.PublicKeyTemplateAttribute(
public_template = objects.TemplateAttribute(
attributes=[
attribute_factory.create_attribute(
enums.AttributeType.CRYPTOGRAPHIC_ALGORITHM,
@ -3083,9 +3099,10 @@ class TestKmipEngine(testtools.TestCase):
enums.AttributeType.CRYPTOGRAPHIC_LENGTH,
2048
)
]
],
tag=enums.Tags.PUBLIC_KEY_TEMPLATE_ATTRIBUTE
)
private_template = objects.PrivateKeyTemplateAttribute(
private_template = objects.TemplateAttribute(
attributes=[
attribute_factory.create_attribute(
enums.AttributeType.CRYPTOGRAPHIC_ALGORITHM,
@ -3101,7 +3118,8 @@ class TestKmipEngine(testtools.TestCase):
enums.CryptographicUsageMask.DECRYPT
]
)
]
],
tag=enums.Tags.PRIVATE_KEY_TEMPLATE_ATTRIBUTE
)
payload = payloads.CreateKeyPairRequestPayload(
common_template,
@ -3127,7 +3145,7 @@ class TestKmipEngine(testtools.TestCase):
e._logger.reset_mock()
# Test that a missing PrivateKey CryptographicUsageMask raises an error
common_template = objects.CommonTemplateAttribute(
common_template = objects.TemplateAttribute(
attributes=[
attribute_factory.create_attribute(
enums.AttributeType.NAME,
@ -3136,9 +3154,10 @@ class TestKmipEngine(testtools.TestCase):
enums.NameType.UNINTERPRETED_TEXT_STRING
)
)
]
],
tag=enums.Tags.COMMON_TEMPLATE_ATTRIBUTE
)
public_template = objects.PublicKeyTemplateAttribute(
public_template = objects.TemplateAttribute(
attributes=[
attribute_factory.create_attribute(
enums.AttributeType.CRYPTOGRAPHIC_ALGORITHM,
@ -3154,9 +3173,10 @@ class TestKmipEngine(testtools.TestCase):
enums.CryptographicUsageMask.ENCRYPT
]
)
]
],
tag=enums.Tags.PUBLIC_KEY_TEMPLATE_ATTRIBUTE
)
private_template = objects.PrivateKeyTemplateAttribute(
private_template = objects.TemplateAttribute(
attributes=[
attribute_factory.create_attribute(
enums.AttributeType.CRYPTOGRAPHIC_ALGORITHM,
@ -3166,7 +3186,8 @@ class TestKmipEngine(testtools.TestCase):
enums.AttributeType.CRYPTOGRAPHIC_LENGTH,
2048
)
]
],
tag=enums.Tags.PRIVATE_KEY_TEMPLATE_ATTRIBUTE
)
payload = payloads.CreateKeyPairRequestPayload(
common_template,
@ -3205,7 +3226,7 @@ class TestKmipEngine(testtools.TestCase):
attribute_factory = factory.AttributeFactory()
# Test that mismatched CryptographicAlgorithms raise an error.
common_template = objects.CommonTemplateAttribute(
common_template = objects.TemplateAttribute(
attributes=[
attribute_factory.create_attribute(
enums.AttributeType.NAME,
@ -3214,9 +3235,10 @@ class TestKmipEngine(testtools.TestCase):
enums.NameType.UNINTERPRETED_TEXT_STRING
)
)
]
],
tag=enums.Tags.COMMON_TEMPLATE_ATTRIBUTE
)
public_template = objects.PublicKeyTemplateAttribute(
public_template = objects.TemplateAttribute(
attributes=[
attribute_factory.create_attribute(
enums.AttributeType.CRYPTOGRAPHIC_ALGORITHM,
@ -3232,9 +3254,10 @@ class TestKmipEngine(testtools.TestCase):
enums.CryptographicUsageMask.ENCRYPT
]
)
]
],
tag=enums.Tags.PUBLIC_KEY_TEMPLATE_ATTRIBUTE
)
private_template = objects.PrivateKeyTemplateAttribute(
private_template = objects.TemplateAttribute(
attributes=[
attribute_factory.create_attribute(
enums.AttributeType.CRYPTOGRAPHIC_ALGORITHM,
@ -3250,7 +3273,8 @@ class TestKmipEngine(testtools.TestCase):
enums.CryptographicUsageMask.DECRYPT
]
)
]
],
tag=enums.Tags.PRIVATE_KEY_TEMPLATE_ATTRIBUTE
)
payload = payloads.CreateKeyPairRequestPayload(
common_template,
@ -3275,7 +3299,7 @@ class TestKmipEngine(testtools.TestCase):
e._logger.reset_mock()
# Test that mismatched CryptographicAlgorithms raise an error.
common_template = objects.CommonTemplateAttribute(
common_template = objects.TemplateAttribute(
attributes=[
attribute_factory.create_attribute(
enums.AttributeType.NAME,
@ -3284,9 +3308,10 @@ class TestKmipEngine(testtools.TestCase):
enums.NameType.UNINTERPRETED_TEXT_STRING
)
)
]
],
tag=enums.Tags.COMMON_TEMPLATE_ATTRIBUTE
)
public_template = objects.PublicKeyTemplateAttribute(
public_template = objects.TemplateAttribute(
attributes=[
attribute_factory.create_attribute(
enums.AttributeType.CRYPTOGRAPHIC_ALGORITHM,
@ -3302,9 +3327,10 @@ class TestKmipEngine(testtools.TestCase):
enums.CryptographicUsageMask.ENCRYPT
]
)
]
],
tag=enums.Tags.PUBLIC_KEY_TEMPLATE_ATTRIBUTE
)
private_template = objects.PrivateKeyTemplateAttribute(
private_template = objects.TemplateAttribute(
attributes=[
attribute_factory.create_attribute(
enums.AttributeType.CRYPTOGRAPHIC_ALGORITHM,
@ -3320,7 +3346,8 @@ class TestKmipEngine(testtools.TestCase):
enums.CryptographicUsageMask.DECRYPT
]
)
]
],
tag=enums.Tags.PRIVATE_KEY_TEMPLATE_ATTRIBUTE
)
payload = payloads.CreateKeyPairRequestPayload(
common_template,
@ -8125,7 +8152,7 @@ class TestKmipEngine(testtools.TestCase):
attribute_factory = factory.AttributeFactory()
common_template = objects.CommonTemplateAttribute(
common_template = objects.TemplateAttribute(
attributes=[
attribute_factory.create_attribute(
enums.AttributeType.NAME,
@ -8142,9 +8169,10 @@ class TestKmipEngine(testtools.TestCase):
enums.AttributeType.CRYPTOGRAPHIC_LENGTH,
2048
)
]
],
tag=enums.Tags.COMMON_TEMPLATE_ATTRIBUTE
)
public_template = objects.PublicKeyTemplateAttribute(
public_template = objects.TemplateAttribute(
attributes=[
attribute_factory.create_attribute(
enums.AttributeType.CRYPTOGRAPHIC_USAGE_MASK,
@ -8152,9 +8180,10 @@ class TestKmipEngine(testtools.TestCase):
enums.CryptographicUsageMask.ENCRYPT
]
)
]
],
tag=enums.Tags.PUBLIC_KEY_TEMPLATE_ATTRIBUTE
)
private_template = objects.PrivateKeyTemplateAttribute(
private_template = objects.TemplateAttribute(
attributes=[
attribute_factory.create_attribute(
enums.AttributeType.CRYPTOGRAPHIC_USAGE_MASK,
@ -8162,7 +8191,8 @@ class TestKmipEngine(testtools.TestCase):
enums.CryptographicUsageMask.DECRYPT
]
)
]
],
tag=enums.Tags.PRIVATE_KEY_TEMPLATE_ATTRIBUTE
)
payload = payloads.CreateKeyPairRequestPayload(
common_template,
@ -8178,9 +8208,9 @@ class TestKmipEngine(testtools.TestCase):
"Processing operation: CreateKeyPair"
)
public_id = response_payload.public_key_uuid.value
public_id = response_payload.public_key_unique_identifier
self.assertEqual('1', public_id)
private_id = response_payload.private_key_uuid.value
private_id = response_payload.private_key_unique_identifier
self.assertEqual('2', private_id)
e._logger.reset_mock()