class KeyBlock(Struct):
class KeyCompressionType(Enumeration):
def __init__(self, value=None):
super(KeyBlock.KeyCompressionType, self).__init__(
enums.KeyCompressionType, value, Tags.KEY_COMPRESSION_TYPE)
def __init__(self,
key_format_type=None,
key_compression_type=None,
key_value=None,
cryptographic_algorithm=None,
cryptographic_length=None,
key_wrapping_data=None):
super(KeyBlock, self).__init__(Tags.KEY_BLOCK)
self.key_format_type = key_format_type
self.key_compression_type = key_compression_type
self.key_value = key_value
self.cryptographic_algorithm = cryptographic_algorithm
self.cryptographic_length = cryptographic_length
self.key_wrapping_data = key_wrapping_data
self.validate()
def read(self, istream):
super(KeyBlock, self).read(istream)
tstream = BytearrayStream(istream.read(self.length))
self.key_format_type = KeyFormatType()
self.key_format_type.read(tstream)
if self.is_tag_next(Tags.KEY_COMPRESSION_TYPE, tstream):
self.key_compression_type = KeyBlock.KeyCompressionType()
self.key_compression_type.read(tstream)
self.key_value = KeyValue()
self.key_value.read(tstream)
if self.is_tag_next(Tags.CRYPTOGRAPHIC_ALGORITHM, tstream):
self.cryptographic_algorithm = attributes.CryptographicAlgorithm()
self.cryptographic_algorithm.read(tstream)
if self.is_tag_next(Tags.CRYPTOGRAPHIC_LENGTH, tstream):
self.cryptographic_length = attributes.CryptographicLength()
self.cryptographic_length.read(tstream)
if self.is_tag_next(Tags.KEY_WRAPPING_DATA, tstream):
self.key_wrapping_data = KeyWrappingData()
self.key_wrapping_data.read(tstream)
self.is_oversized(tstream)
self.validate()
def write(self, ostream):
tstream = BytearrayStream()
self.key_format_type.write(tstream)
if self.key_compression_type is not None:
self.key_compression_type.write(tstream)
self.key_value.write(tstream)
if self.cryptographic_algorithm is not None:
self.cryptographic_algorithm.write(tstream)
if self.cryptographic_length is not None:
self.cryptographic_length.write(tstream)
if self.key_wrapping_data is not None:
self.key_wrapping_data.write(tstream)
# Write the length and value of the credential
self.length = tstream.length()
super(KeyBlock, self).write(ostream)
ostream.write(tstream.buffer)
def validate(self):
self.__validate()
def __validate(self):
if self.key_format_type is not None:
if type(self.key_format_type) is not KeyFormatType:
member = 'KeyBlock.key_format_type'
exp_type = KeyFormatType
rcv_type = type(self.key_format_type)
msg = ErrorStrings.BAD_EXP_RECV.format(member, 'type',
exp_type, rcv_type)
raise TypeError(msg)
class Digest(Struct):
"""
A structure storing a hash digest of a Managed Object.
Digests may be calculated for keys, secret data objects, certificates, and
opaque data objects and are generated when the object is created or
registered with the KMIP server. See Section 3.17 of the KMIP 1.1
specification for more information.
Attributes:
hashing_algorithm: The algorithm used to compute the hash digest.
digest_value: The bytes representing the hash digest value.
key_format_type: The type of the key the hash was generated for.
"""
def __init__(self,
hashing_algorithm=None,
digest_value=None,
key_format_type=None):
"""
Construct a Digest object.
Args:
hashing_algorithm (HashingAlgorithm): The hash algorithm used to
compute the value of the digest. Optional, defaults to None.
digest_value (DigestValue): The byte string representing the
value of the hash digest. Optional, defaults to None.
key_format_type (KeyFormatType): The format type of the key the
hash was computed for, if the object in question is a key.
Optional, defaults to None.
"""
super(Digest, self).__init__(Tags.DIGEST)
if hashing_algorithm is None:
self.hashing_algorithm = HashingAlgorithm()
else:
self.hashing_algorithm = hashing_algorithm
if digest_value is None:
self.digest_value = DigestValue()
else:
self.digest_value = digest_value
if key_format_type is None:
self.key_format_type = KeyFormatType()
else:
self.key_format_type = key_format_type
self.validate()
def read(self, istream):
"""
Read the data encoding the Digest 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(Digest, self).read(istream)
tstream = BytearrayStream(istream.read(self.length))
self.hashing_algorithm.read(tstream)
self.digest_value.read(tstream)
self.key_format_type.read(tstream)
self.is_oversized(tstream)
self.validate()
def write(self, ostream):
"""
Write the data encoding the Digest 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.hashing_algorithm.write(tstream)
self.digest_value.write(tstream)
self.key_format_type.write(tstream)
self.length = tstream.length()
super(Digest, self).write(ostream)
ostream.write(tstream.buffer)
def validate(self):
"""
Error check the attributes of the Digest object.
"""
self.__validate()
def __validate(self):
# TODO (peter-hamilton) Add checks comparing the length of the digest
# value against the standard length for the stated hashing algorithm.
if not isinstance(self.hashing_algorithm, HashingAlgorithm):
msg = "invalid hashing algorithm"
msg += "; expected {0}, received {1}".format(
HashingAlgorithm, self.hashing_algorithm)
raise TypeError(msg)
if not isinstance(self.digest_value, DigestValue):
msg = "invalid digest value"
msg += "; expected {0}, received {1}".format(
DigestValue, self.digest_value)
raise TypeError(msg)
if not isinstance(self.key_format_type, KeyFormatType):
msg = "invalid key format type"
msg += "; expected {0}, received {1}".format(
KeyFormatType, self.key_format_type)
raise TypeError(msg)
def __eq__(self, other):
if isinstance(other, Digest):
if self.hashing_algorithm != other.hashing_algorithm:
return False
elif self.digest_value != other.digest_value:
return False
elif self.key_format_type != other.key_format_type:
return False
else:
return True
else:
return NotImplemented
def __ne__(self, other):
if isinstance(other, Digest):
return not (self == other)
else:
return NotImplemented
def __repr__(self):
hashing_algorithm = "hashing_algorithm={0}".format(
repr(self.hashing_algorithm))
digest_value = "digest_value={0}".format(
repr(self.digest_value))
key_format_type = "key_format_type={0}".format(
repr(self.key_format_type))
return "Digest({0}, {1}, {2})".format(
hashing_algorithm, digest_value, key_format_type)
def __str__(self):
return str(self.digest_value)
@classmethod
def create(cls,
hashing_algorithm=HashingAlgorithmEnum.SHA_256,
digest_value=b'',
key_format_type=KeyFormatTypeEnum.RAW):
"""
Construct a Digest object from provided digest values.
Args:
hashing_algorithm (HashingAlgorithm): An enumeration representing
the hash algorithm used to compute the digest. Optional,
defaults to HashingAlgorithm.SHA_256.
digest_value (byte string): The bytes of the digest hash. Optional,
defaults to the empty byte string.
key_format_type (KeyFormatType): An enumeration representing the
format of the key corresponding to the digest. Optional,
defaults to KeyFormatType.RAW.
Returns:
Digest: The newly created Digest.
Example:
>>> x = Digest.create(HashingAlgorithm.MD5, b'\x00',
... KeyFormatType.RAW)
>>> x.hashing_algorithm
HashingAlgorithm(value=HashingAlgorithm.MD5)
>>> x.digest_value
DigestValue(value=bytearray(b'\x00'))
>>> x.key_format_type
KeyFormatType(value=KeyFormatType.RAW)
"""
algorithm = HashingAlgorithm(hashing_algorithm)
value = DigestValue(bytearray(digest_value))
format_type = KeyFormatType(key_format_type)
return Digest(hashing_algorithm=algorithm,
digest_value=value,
key_format_type=format_type)
class KeyBlock(Struct):
class KeyCompressionType(Enumeration):
ENUM_TYPE = enums.KeyCompressionType
def __init__(self, value=None):
super(self.__class__, self).__init__(value,
Tags.KEY_COMPRESSION_TYPE)
def __init__(self,
key_format_type=None,
key_compression_type=None,
key_value=None,
cryptographic_algorithm=None,
cryptographic_length=None,
key_wrapping_data=None):
super(self.__class__, self).__init__(Tags.KEY_BLOCK)
self.key_format_type = key_format_type
self.key_compression_type = key_compression_type
self.key_value = key_value
self.cryptographic_algorithm = cryptographic_algorithm
self.cryptographic_length = cryptographic_length
self.key_wrapping_data = key_wrapping_data
self.validate()
def read(self, istream):
super(self.__class__, self).read(istream)
tstream = BytearrayStream(istream.read(self.length))
self.key_format_type = KeyFormatType()
self.key_format_type.read(tstream)
if self.is_tag_next(Tags.KEY_COMPRESSION_TYPE, tstream):
self.key_compression_type = KeyBlock.KeyCompressionType()
self.key_compression_type.read(tstream)
self.key_value = KeyValue()
self.key_value.read(tstream)
if self.is_tag_next(Tags.CRYPTOGRAPHIC_ALGORITHM, tstream):
self.cryptographic_algorithm = attributes.CryptographicAlgorithm()
self.cryptographic_algorithm.read(tstream)
if self.is_tag_next(Tags.CRYPTOGRAPHIC_LENGTH, tstream):
self.cryptographic_length = attributes.CryptographicLength()
self.cryptographic_length.read(tstream)
if self.is_tag_next(Tags.KEY_WRAPPING_DATA, tstream):
self.key_wrapping_data = KeyWrappingData()
self.key_wrapping_data.read(tstream)
self.is_oversized(tstream)
self.validate()
def write(self, ostream):
tstream = BytearrayStream()
self.key_format_type.write(tstream)
if self.key_compression_type is not None:
self.key_compression_type.write(tstream)
self.key_value.write(tstream)
if self.cryptographic_algorithm is not None:
self.cryptographic_algorithm.write(tstream)
if self.cryptographic_length is not None:
self.cryptographic_length.write(tstream)
if self.key_wrapping_data is not None:
self.key_wrapping_data.write(tstream)
# Write the length and value of the credential
self.length = tstream.length()
super(self.__class__, self).write(ostream)
ostream.write(tstream.buffer)
def validate(self):
self.__validate()
def __validate(self):
if self.key_format_type is not None:
if type(self.key_format_type) is not KeyFormatType:
member = 'KeyBlock.key_format_type'
exp_type = KeyFormatType
rcv_type = type(self.key_format_type)
msg = ErrorStrings.BAD_EXP_RECV.format(member, 'type',
exp_type, rcv_type)
raise TypeError(msg)
class Digest(Struct):
"""
A structure storing a hash digest of a Managed Object.
Digests may be calculated for keys, secret data objects, certificates, and
opaque data objects and are generated when the object is created or
registered with the KMIP server. See Section 3.17 of the KMIP 1.1
specification for more information.
Attributes:
hashing_algorithm: The algorithm used to compute the hash digest.
digest_value: The bytes representing the hash digest value.
key_format_type: The type of the key the hash was generated for.
"""
def __init__(self,
hashing_algorithm=None,
digest_value=None,
key_format_type=None):
"""
Construct a Digest object.
Args:
hashing_algorithm (HashingAlgorithm): The hash algorithm used to
compute the value of the digest. Optional, defaults to None.
digest_value (DigestValue): The byte string representing the
value of the hash digest. Optional, defaults to None.
key_format_type (KeyFormatType): The format type of the key the
hash was computed for, if the object in question is a key.
Optional, defaults to None.
"""
super(Digest, self).__init__(Tags.DIGEST)
if hashing_algorithm is None:
self.hashing_algorithm = HashingAlgorithm()
else:
self.hashing_algorithm = hashing_algorithm
if digest_value is None:
self.digest_value = DigestValue()
else:
self.digest_value = digest_value
if key_format_type is None:
self.key_format_type = KeyFormatType()
else:
self.key_format_type = key_format_type
self.validate()
def read(self, istream):
"""
Read the data encoding the Digest 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(Digest, self).read(istream)
tstream = BytearrayStream(istream.read(self.length))
self.hashing_algorithm.read(tstream)
self.digest_value.read(tstream)
self.key_format_type.read(tstream)
self.is_oversized(tstream)
self.validate()
def write(self, ostream):
"""
Write the data encoding the Digest 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.hashing_algorithm.write(tstream)
self.digest_value.write(tstream)
self.key_format_type.write(tstream)
self.length = tstream.length()
super(Digest, self).write(ostream)
ostream.write(tstream.buffer)
def validate(self):
"""
Error check the attributes of the Digest object.
"""
self.__validate()
def __validate(self):
# TODO (peter-hamilton) Add checks comparing the length of the digest
# value against the standard length for the stated hashing algorithm.
if not isinstance(self.hashing_algorithm, HashingAlgorithm):
msg = "invalid hashing algorithm"
msg += "; expected {0}, received {1}".format(
HashingAlgorithm, self.hashing_algorithm)
raise TypeError(msg)
if not isinstance(self.digest_value, DigestValue):
msg = "invalid digest value"
msg += "; expected {0}, received {1}".format(
DigestValue, self.digest_value)
raise TypeError(msg)
if not isinstance(self.key_format_type, KeyFormatType):
msg = "invalid key format type"
msg += "; expected {0}, received {1}".format(
KeyFormatType, self.key_format_type)
raise TypeError(msg)
def __eq__(self, other):
if isinstance(other, Digest):
if self.hashing_algorithm != other.hashing_algorithm:
return False
elif self.digest_value != other.digest_value:
return False
elif self.key_format_type != other.key_format_type:
return False
else:
return True
else:
return NotImplemented
def __ne__(self, other):
if isinstance(other, Digest):
return not (self == other)
else:
return NotImplemented
def __repr__(self):
hashing_algorithm = "hashing_algorithm={0}".format(
repr(self.hashing_algorithm))
digest_value = "digest_value={0}".format(
repr(self.digest_value))
key_format_type = "key_format_type={0}".format(
repr(self.key_format_type))
return "Digest({0}, {1}, {2})".format(
hashing_algorithm, digest_value, key_format_type)
def __str__(self):
return str(self.digest_value)
@classmethod
def create(cls,
hashing_algorithm=HashingAlgorithmEnum.SHA_256,
digest_value=b'',
key_format_type=KeyFormatTypeEnum.RAW):
"""
Construct a Digest object from provided digest values.
Args:
hashing_algorithm (HashingAlgorithm): An enumeration representing
the hash algorithm used to compute the digest. Optional,
defaults to HashingAlgorithm.SHA_256.
digest_value (byte string): The bytes of the digest hash. Optional,
defaults to the empty byte string.
key_format_type (KeyFormatType): An enumeration representing the
format of the key corresponding to the digest. Optional,
defaults to KeyFormatType.RAW.
Returns:
Digest: The newly created Digest.
Example:
>>> x = Digest.create(HashingAlgorithm.MD5, b'\x00',
... KeyFormatType.RAW)
>>> x.hashing_algorithm
HashingAlgorithm(value=HashingAlgorithm.MD5)
>>> x.digest_value
DigestValue(value=bytearray(b'\x00'))
>>> x.key_format_type
KeyFormatType(value=KeyFormatType.RAW)
"""
algorithm = HashingAlgorithm(hashing_algorithm)
value = DigestValue(bytearray(digest_value))
format_type = KeyFormatType(key_format_type)
return Digest(hashing_algorithm=algorithm,
digest_value=value,
key_format_type=format_type)
