mirror of
https://github.com/OpenKMIP/PyKMIP.git
synced 2025-05-03 06:20:08 +02:00
0c4f9cd9d0
This change updates the various Application attributes, adding inline documentation, and reorganizing the different related test suites. Minor updates to supporting primitive objects are included.
482 lines
16 KiB
Python
482 lines
16 KiB
Python
# Copyright (c) 2014 The Johns Hopkins University/Applied Physics Laboratory
|
|
# All Rights Reserved.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License"); you may
|
|
# not use this file except in compliance with the License. You may obtain
|
|
# a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
# License for the specific language governing permissions and limitations
|
|
# under the License.
|
|
|
|
from kmip.core import enums
|
|
|
|
from kmip.core.enums import Tags
|
|
|
|
from kmip.core.errors import ErrorStrings
|
|
|
|
from kmip.core.primitives import Struct
|
|
from kmip.core.primitives import Integer
|
|
from kmip.core.primitives import Enumeration
|
|
from kmip.core.primitives import TextString
|
|
|
|
from kmip.core.utils import BytearrayStream
|
|
from enum import Enum
|
|
|
|
|
|
# 3.1
|
|
class UniqueIdentifier(TextString):
|
|
|
|
def __init__(self, value=None, tag=Tags.UNIQUE_IDENTIFIER):
|
|
super(UniqueIdentifier, self).__init__(value, tag)
|
|
|
|
|
|
class PrivateKeyUniqueIdentifier(UniqueIdentifier):
|
|
|
|
def __init__(self, value=None):
|
|
super(PrivateKeyUniqueIdentifier, self).__init__(
|
|
value, Tags.PRIVATE_KEY_UNIQUE_IDENTIFIER)
|
|
|
|
|
|
class PublicKeyUniqueIdentifier(UniqueIdentifier):
|
|
|
|
def __init__(self, value=None):
|
|
super(PublicKeyUniqueIdentifier, self).__init__(
|
|
value, Tags.PUBLIC_KEY_UNIQUE_IDENTIFIER)
|
|
|
|
|
|
# 3.2
|
|
class Name(Struct):
|
|
|
|
class NameValue(TextString):
|
|
|
|
def __init__(self, value=None):
|
|
super(self.__class__, self).__init__(value, Tags.NAME_VALUE)
|
|
|
|
class NameType(Enumeration):
|
|
|
|
ENUM_TYPE = enums.NameType
|
|
|
|
def __init__(self, value=None):
|
|
super(self.__class__, self).__init__(value, Tags.NAME_TYPE)
|
|
|
|
def __init__(self, name_value=None, name_type=None):
|
|
super(self.__class__, self).__init__(tag=Tags.NAME)
|
|
self.name_value = name_value
|
|
self.name_type = name_type
|
|
self.validate()
|
|
|
|
def read(self, istream):
|
|
super(self.__class__, self).read(istream)
|
|
tstream = BytearrayStream(istream.read(self.length))
|
|
|
|
# Read the value and type of the name
|
|
self.name_value = Name.NameValue()
|
|
self.name_type = Name.NameType()
|
|
self.name_value.read(tstream)
|
|
self.name_type.read(tstream)
|
|
|
|
self.is_oversized(tstream)
|
|
|
|
def write(self, ostream):
|
|
tstream = BytearrayStream()
|
|
|
|
# Write the value and type of the name
|
|
self.name_value.write(tstream)
|
|
self.name_type.write(tstream)
|
|
|
|
# Write the length and value of the template attribute
|
|
self.length = tstream.length()
|
|
super(self.__class__, self).write(ostream)
|
|
ostream.write(tstream.buffer)
|
|
|
|
def validate(self):
|
|
self.__validate()
|
|
|
|
def __validate(self):
|
|
name = self.__class__.__name__
|
|
msg = ErrorStrings.BAD_EXP_RECV
|
|
if self.name_value and \
|
|
not isinstance(self.name_value, Name.NameValue) and \
|
|
not isinstance(self.name_value, str):
|
|
member = 'name_value'
|
|
raise TypeError(msg.format('{0}.{1}'.format(name, member),
|
|
'name_value', type(Name.NameValue),
|
|
type(self.name_value)))
|
|
if self.name_type and \
|
|
not isinstance(self.name_type, Name.NameType) and \
|
|
not isinstance(self.name_type, str):
|
|
member = 'name_type'
|
|
raise TypeError(msg.format('{0}.{1}'.format(name, member),
|
|
'name_type', type(Name.NameType),
|
|
type(self.name_type)))
|
|
|
|
@classmethod
|
|
def create(cls, name_value, name_type):
|
|
if isinstance(name_value, Name.NameValue):
|
|
value = name_value
|
|
elif isinstance(name_value, str):
|
|
value = cls.NameValue(name_value)
|
|
else:
|
|
name = 'Name'
|
|
msg = ErrorStrings.BAD_EXP_RECV
|
|
member = 'name_value'
|
|
raise TypeError(msg.format('{0}.{1}'.format(name, member),
|
|
'name_value', type(Name.NameValue),
|
|
type(name_value)))
|
|
|
|
if isinstance(name_type, Name.NameType):
|
|
n_type = name_type
|
|
elif isinstance(name_type, Enum):
|
|
n_type = cls.NameType(name_type)
|
|
else:
|
|
name = 'Name'
|
|
msg = ErrorStrings.BAD_EXP_RECV
|
|
member = 'name_type'
|
|
raise TypeError(msg.format('{0}.{1}'.format(name, member),
|
|
'name_type', type(Name.NameType),
|
|
type(name_type)))
|
|
|
|
return Name(name_value=value,
|
|
name_type=n_type)
|
|
|
|
|
|
# 3.3
|
|
class ObjectType(Enumeration):
|
|
|
|
ENUM_TYPE = enums.ObjectType
|
|
|
|
def __init__(self, value=None):
|
|
super(self.__class__, self).__init__(value, Tags.OBJECT_TYPE)
|
|
|
|
|
|
# 3.4
|
|
class CryptographicAlgorithm(Enumeration):
|
|
|
|
ENUM_TYPE = enums.CryptographicAlgorithm
|
|
|
|
def __init__(self, value=None):
|
|
super(self.__class__, self).__init__(value,
|
|
Tags.CRYPTOGRAPHIC_ALGORITHM)
|
|
|
|
|
|
# 3.5
|
|
class CryptographicLength(Integer):
|
|
|
|
def __init__(self, value=None):
|
|
super(self.__class__, self).__init__(value,
|
|
Tags.CRYPTOGRAPHIC_LENGTH)
|
|
|
|
|
|
# 3.6
|
|
class CryptographicParameters(Struct):
|
|
|
|
class BlockCipherMode(Enumeration):
|
|
ENUM_TYPE = enums.BlockCipherMode
|
|
|
|
def __init__(self, value=None):
|
|
super(self.__class__, self).__init__(value,
|
|
Tags.BLOCK_CIPHER_MODE)
|
|
|
|
class PaddingMethod(Enumeration):
|
|
ENUM_TYPE = enums.PaddingMethod
|
|
|
|
def __init__(self, value=None):
|
|
super(self.__class__, self).__init__(value,
|
|
Tags.PADDING_METHOD)
|
|
|
|
class HashingAlgorithm(Enumeration):
|
|
ENUM_TYPE = enums.HashingAlgorithm
|
|
|
|
def __init__(self, value=None):
|
|
super(self.__class__, self).__init__(value,
|
|
Tags.HASHING_ALGORITHM)
|
|
|
|
class KeyRoleType(Enumeration):
|
|
ENUM_TYPE = enums.KeyRoleType
|
|
|
|
def __init__(self, value=None):
|
|
super(self.__class__, self).__init__(value,
|
|
Tags.KEY_ROLE_TYPE)
|
|
|
|
def __init__(self,
|
|
block_cipher_mode=None,
|
|
padding_method=None,
|
|
hashing_algorithm=None,
|
|
key_role_type=None):
|
|
super(self.__class__, self).__init__(tag=Tags.CRYPTOGRAPHIC_PARAMETERS)
|
|
self.block_cipher_mode = block_cipher_mode
|
|
self.padding_method = padding_method
|
|
self.hashing_algorithm = hashing_algorithm
|
|
self.key_role_type = key_role_type
|
|
|
|
def read(self, istream):
|
|
super(self.__class__, self).read(istream)
|
|
tstream = BytearrayStream(istream.read(self.length))
|
|
|
|
if self.is_tag_next(Tags.BLOCK_CIPHER_MODE, tstream):
|
|
self.block_cipher_mode = CryptographicParameters.BlockCipherMode()
|
|
self.block_cipher_mode.read(tstream)
|
|
|
|
if self.is_tag_next(Tags.PADDING_METHOD, tstream):
|
|
self.padding_method = CryptographicParameters.PaddingMethod()
|
|
self.padding_method.read(tstream)
|
|
|
|
if self.is_tag_next(Tags.HASHING_ALGORITHM, tstream):
|
|
self.hashing_algorithm = CryptographicParameters.HashingAlgorithm()
|
|
self.hashing_algorithm.read(tstream)
|
|
|
|
if self.is_tag_next(Tags.KEY_ROLE_TYPE, tstream):
|
|
self.key_role_type = CryptographicParameters.KeyRoleType()
|
|
self.key_role_type.read(tstream)
|
|
|
|
self.is_oversized(tstream)
|
|
self.validate()
|
|
|
|
def write(self, ostream):
|
|
tstream = BytearrayStream()
|
|
|
|
# Write the contents of the request payload
|
|
if self.block_cipher_mode is not None:
|
|
self.block_cipher_mode.write(tstream)
|
|
if self.padding_method is not None:
|
|
self.padding_method.write(tstream)
|
|
if self.hashing_algorithm is not None:
|
|
self.hashing_algorithm.write(tstream)
|
|
if self.key_role_type is not None:
|
|
self.key_role_type.write(tstream)
|
|
|
|
# Write the length and value of the request payload
|
|
self.length = tstream.length()
|
|
super(self.__class__, self).write(ostream)
|
|
ostream.write(tstream.buffer)
|
|
|
|
def validate(self):
|
|
self.__validate()
|
|
|
|
def __validate(self):
|
|
# TODO (peter-hamilton) Finish implementation.
|
|
pass
|
|
|
|
|
|
# 3.8
|
|
class CertificateType(Enumeration):
|
|
ENUM_TYPE = enums.CertificateType
|
|
|
|
def __init__(self, value=None):
|
|
super(self.__class__, self).__init__(value,
|
|
Tags.CERTIFICATE_TYPE)
|
|
|
|
|
|
# 3.18
|
|
class OperationPolicyName(TextString):
|
|
|
|
def __init__(self, value=None):
|
|
super(OperationPolicyName, self).__init__(
|
|
value, Tags.OPERATION_POLICY_NAME)
|
|
|
|
|
|
# 3.19
|
|
class CryptographicUsageMask(Integer):
|
|
|
|
ENUM_TYPE = enums.CryptographicUsageMask
|
|
|
|
def __init__(self, value=None):
|
|
super(self.__class__, self).__init__(value,
|
|
Tags.CRYPTOGRAPHIC_USAGE_MASK)
|
|
|
|
|
|
# 3.33
|
|
class ObjectGroup(TextString):
|
|
|
|
def __init__(self, value=None):
|
|
super(self.__class__,
|
|
self).__init__(value, Tags.OBJECT_GROUP)
|
|
|
|
|
|
# 3.36
|
|
class ApplicationNamespace(TextString):
|
|
"""
|
|
The name of a namespace supported by the KMIP server.
|
|
|
|
A part of ApplicationSpecificInformation, sets of these are also potential
|
|
responses to a Query request. See Sections 3.36 and 4.25 of the KMIP v1.1
|
|
specification for more information.
|
|
"""
|
|
|
|
def __init__(self, value=None):
|
|
"""
|
|
Construct an ApplicationNamespace object.
|
|
|
|
Args:
|
|
value (str): A string representing a namespace. Optional, defaults
|
|
to None.
|
|
"""
|
|
super(ApplicationNamespace, self).__init__(
|
|
value, Tags.APPLICATION_NAMESPACE)
|
|
|
|
|
|
class ApplicationData(TextString):
|
|
"""
|
|
A string representing data specific to an application namespace.
|
|
|
|
A part of ApplicationSpecificInformation. See Section 3.36 of the KMIP v1.1
|
|
specification for more information.
|
|
"""
|
|
|
|
def __init__(self, value=None):
|
|
"""
|
|
Construct an ApplicationData object.
|
|
|
|
Args:
|
|
value (str): A string representing data for a particular namespace.
|
|
Optional, defaults to None.
|
|
"""
|
|
super(ApplicationData, self).__init__(value, Tags.APPLICATION_DATA)
|
|
|
|
|
|
class ApplicationSpecificInformation(Struct):
|
|
"""
|
|
A structure used to store data specific to the applications that use a
|
|
Managed Object.
|
|
|
|
An attribute of Managed Objects, it may be specified during the creation or
|
|
modification of any server Managed Object.
|
|
|
|
Attributes:
|
|
application_namespace: The name of a namespace supported by the server.
|
|
application_data: String data relevant to the specified namespace.
|
|
|
|
See Section 3.36 of the KMIP v1.1 specification for more information.
|
|
"""
|
|
|
|
def __init__(self, application_namespace=None, application_data=None):
|
|
"""
|
|
Construct an ApplicationSpecificInformation object.
|
|
|
|
Args:
|
|
application_namespace (ApplicationNamespace): The name of a
|
|
namespace supported by the server. Optional, defaults to None.
|
|
application_data (ApplicationData): String data relevant to the
|
|
specified namespace. Optional, defaults to None.
|
|
"""
|
|
super(ApplicationSpecificInformation, self).__init__(
|
|
Tags.APPLICATION_SPECIFIC_INFORMATION)
|
|
|
|
if application_namespace is None:
|
|
self.application_namespace = ApplicationNamespace()
|
|
else:
|
|
self.application_namespace = application_namespace
|
|
|
|
if application_data is None:
|
|
self.application_data = ApplicationData()
|
|
else:
|
|
self.application_data = application_data
|
|
|
|
self.validate()
|
|
|
|
def read(self, istream):
|
|
"""
|
|
Read the data encoding the ApplicationSpecificInformation 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(ApplicationSpecificInformation, self).read(istream)
|
|
tstream = BytearrayStream(istream.read(self.length))
|
|
|
|
self.application_namespace.read(tstream)
|
|
self.application_data.read(tstream)
|
|
|
|
self.is_oversized(tstream)
|
|
self.validate()
|
|
|
|
def write(self, ostream):
|
|
"""
|
|
Write the data encoding the ApplicationSpecificInformation object to a
|
|
stream.
|
|
|
|
Args:
|
|
ostream (Stream): A data stream in which to encode object data,
|
|
supporting a write method; usually a BytearrayStream object.
|
|
"""
|
|
tstream = BytearrayStream()
|
|
|
|
self.application_namespace.write(tstream)
|
|
self.application_data.write(tstream)
|
|
|
|
self.length = tstream.length()
|
|
super(ApplicationSpecificInformation, self).write(ostream)
|
|
ostream.write(tstream.buffer)
|
|
|
|
def validate(self):
|
|
"""
|
|
Error check the types of the different attributes of the
|
|
ApplicationSpecificInformation object.
|
|
"""
|
|
self.__validate()
|
|
|
|
def __validate(self):
|
|
if not isinstance(self.application_namespace, ApplicationNamespace):
|
|
msg = "invalid application namespace"
|
|
msg += "; expected {0}, received {1}".format(
|
|
ApplicationNamespace, self.application_namespace)
|
|
raise TypeError(msg)
|
|
|
|
if not isinstance(self.application_data, ApplicationData):
|
|
msg = "invalid application data"
|
|
msg += "; expected {0}, received {1}".format(
|
|
ApplicationData, self.application_data)
|
|
raise TypeError(msg)
|
|
|
|
@classmethod
|
|
def create(cls, application_namespace, application_data):
|
|
"""
|
|
Construct an ApplicationSpecificInformation object from provided data
|
|
and namespace values.
|
|
|
|
Args:
|
|
application_namespace (str): The name of the application namespace.
|
|
application_data (str): Application data related to the namespace.
|
|
|
|
Returns:
|
|
ApplicationSpecificInformation: The newly created set of
|
|
application information.
|
|
|
|
Example:
|
|
>>> x = ApplicationSpecificInformation.create('namespace', 'data')
|
|
>>> x.application_namespace.value
|
|
'namespace'
|
|
>>> x.application_data.value
|
|
'data'
|
|
"""
|
|
namespace = ApplicationNamespace(application_namespace)
|
|
data = ApplicationData(application_data)
|
|
return ApplicationSpecificInformation(
|
|
application_namespace=namespace, application_data=data)
|
|
|
|
|
|
# 3.37
|
|
class ContactInformation(TextString):
|
|
|
|
def __init__(self, value=None):
|
|
super(self.__class__,
|
|
self).__init__(value, Tags.CONTACT_INFORMATION)
|
|
|
|
|
|
# 3.39
|
|
# TODO (peter-hamilton) A CustomAttribute TextString is not sufficient to
|
|
# TODO (peter-hamilton) cover all potential custom attributes. This is a
|
|
# TODO (peter-hamilton) temporary stopgap.
|
|
class CustomAttribute(TextString):
|
|
|
|
def __init__(self, value=None):
|
|
super(self.__class__,
|
|
self).__init__(value, Tags.ATTRIBUTE_VALUE)
|