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)