Merge pull request #286 from OpenKMIP/feat/update-crypto-param

Updating the CryptographicParameters struct

kmip/core/attributes.py

@@ -13,6 +13,8 @@
 # License for the specific language governing permissions and limitations
 # under the License.
 
+import six
+
 from kmip.core import enums
 
 from kmip.core.enums import CertificateTypeEnum
@@ -24,6 +26,7 @@ from kmip.core.errors import ErrorStrings
 
 from kmip.core.misc import KeyFormatType
 
+from kmip.core.primitives import Boolean
 from kmip.core.primitives import ByteString
 from kmip.core.primitives import Enumeration
 from kmip.core.primitives import Integer
@@ -255,163 +258,468 @@ class HashingAlgorithm(Enumeration):
 
 
 class CryptographicParameters(Struct):
+    """
+    A set of values for cryptographic operations.
 
-    class BlockCipherMode(Enumeration):
+    A structure containing optional fields describing certain cryptographic
+    parameters to be used when performing cryptographic operations with the
+    associated KMIP object.
+    """
 
-        def __init__(self, value=None):
-            super(CryptographicParameters.BlockCipherMode, self).__init__(
-                enums.BlockCipherMode, value, Tags.BLOCK_CIPHER_MODE)
-
-    class PaddingMethod(Enumeration):
-
-        def __init__(self, value=None):
-            super(CryptographicParameters.PaddingMethod, self).__init__(
-                enums.PaddingMethod, value, Tags.PADDING_METHOD)
-
-    class KeyRoleType(Enumeration):
-
-        def __init__(self, value=None):
-            super(CryptographicParameters.KeyRoleType, self).__init__(
-                enums.KeyRoleType, value, Tags.KEY_ROLE_TYPE)
-
-    class DigitalSignatureAlgorithm(Enumeration):
-
-        def __init__(self, value=None):
-            super(CryptographicParameters.DigitalSignatureAlgorithm,
-                  self).__init__(enums.DigitalSignatureAlgorithm,
-                                 value, Tags.DIGITAL_SIGNATURE_ALGORITHM)
-
-    # TODO: Need to implement other fields of CryptographicParameters (3.6)
     def __init__(self,
                  block_cipher_mode=None,
                  padding_method=None,
                  hashing_algorithm=None,
                  key_role_type=None,
                  digital_signature_algorithm=None,
-                 cryptographic_algorithm=None):
+                 cryptographic_algorithm=None,
+                 random_iv=None,
+                 iv_length=None,
+                 tag_length=None,
+                 fixed_field_length=None,
+                 invocation_field_length=None,
+                 counter_length=None,
+                 initial_counter_value=None):
         super(CryptographicParameters, self).__init__(
             tag=Tags.CRYPTOGRAPHIC_PARAMETERS)
+
+        self._block_cipher_mode = None
+        self._padding_method = None
+        self._hashing_algorithm = None
+        self._key_role_type = None
+        self._digital_signature_algorithm = None
+        self._cryptographic_algorithm = None
+        self._random_iv = None
+        self._iv_length = None
+        self._tag_length = None
+        self._fixed_field_length = None
+        self._invocation_field_length = None
+        self._counter_length = None
+        self._initial_counter_value = None
+
         self.block_cipher_mode = block_cipher_mode
         self.padding_method = padding_method
         self.hashing_algorithm = hashing_algorithm
         self.key_role_type = key_role_type
         self.digital_signature_algorithm = digital_signature_algorithm
         self.cryptographic_algorithm = cryptographic_algorithm
+        self.random_iv = random_iv
+        self.iv_length = iv_length
+        self.tag_length = tag_length
+        self.fixed_field_length = fixed_field_length
+        self.invocation_field_length = invocation_field_length
+        self.counter_length = counter_length
+        self.initial_counter_value = initial_counter_value
+
+    @property
+    def block_cipher_mode(self):
+        if self._block_cipher_mode:
+            return self._block_cipher_mode.value
+        else:
+            return None
+
+    @block_cipher_mode.setter
+    def block_cipher_mode(self, value):
+        if value is None:
+            self._block_cipher_mode = None
+        elif isinstance(value, enums.BlockCipherMode):
+            self._block_cipher_mode = Enumeration(
+                enums.BlockCipherMode,
+                value=value,
+                tag=Tags.BLOCK_CIPHER_MODE
+            )
+        else:
+            raise TypeError(
+                "block cipher mode must be a BlockCipherMode enumeration"
+            )
+
+    @property
+    def padding_method(self):
+        if self._padding_method:
+            return self._padding_method.value
+        else:
+            return None
+
+    @padding_method.setter
+    def padding_method(self, value):
+        if value is None:
+            self._padding_method = None
+        elif isinstance(value, enums.PaddingMethod):
+            self._padding_method = Enumeration(
+                enums.PaddingMethod,
+                value=value,
+                tag=Tags.PADDING_METHOD
+            )
+        else:
+            raise TypeError(
+                "padding method must be a PaddingMethod enumeration"
+            )
+
+    @property
+    def hashing_algorithm(self):
+        if self._hashing_algorithm:
+            return self._hashing_algorithm.value
+        else:
+            return None
+
+    @hashing_algorithm.setter
+    def hashing_algorithm(self, value):
+        if value is None:
+            self._hashing_algorithm = None
+        elif isinstance(value, enums.HashingAlgorithm):
+            self._hashing_algorithm = Enumeration(
+                enums.HashingAlgorithm,
+                value=value,
+                tag=Tags.HASHING_ALGORITHM
+            )
+        else:
+            raise TypeError(
+                "hashing algorithm must be a HashingAlgorithm enumeration"
+            )
+
+    @property
+    def key_role_type(self):
+        if self._key_role_type:
+            return self._key_role_type.value
+        else:
+            return None
+
+    @key_role_type.setter
+    def key_role_type(self, value):
+        if value is None:
+            self._key_role_type = None
+        elif isinstance(value, enums.KeyRoleType):
+            self._key_role_type = Enumeration(
+                enums.KeyRoleType,
+                value=value,
+                tag=Tags.KEY_ROLE_TYPE
+            )
+        else:
+            raise TypeError(
+                "key role type must be a KeyRoleType enumeration"
+            )
+
+    @property
+    def digital_signature_algorithm(self):
+        if self._digital_signature_algorithm:
+            return self._digital_signature_algorithm.value
+        else:
+            return None
+
+    @digital_signature_algorithm.setter
+    def digital_signature_algorithm(self, value):
+        if value is None:
+            self._digital_signature_algorithm = None
+        elif isinstance(value, enums.DigitalSignatureAlgorithm):
+            self._digital_signature_algorithm = Enumeration(
+                enums.DigitalSignatureAlgorithm,
+                value=value,
+                tag=Tags.DIGITAL_SIGNATURE_ALGORITHM
+            )
+        else:
+            raise TypeError(
+                "digital signature algorithm must be a "
+                "DigitalSignatureAlgorithm enumeration"
+            )
+
+    @property
+    def cryptographic_algorithm(self):
+        if self._cryptographic_algorithm:
+            return self._cryptographic_algorithm.value
+        else:
+            return None
+
+    @cryptographic_algorithm.setter
+    def cryptographic_algorithm(self, value):
+        if value is None:
+            self._cryptographic_algorithm = None
+        elif isinstance(value, enums.CryptographicAlgorithm):
+            self._cryptographic_algorithm = Enumeration(
+                enums.CryptographicAlgorithm,
+                value=value,
+                tag=Tags.CRYPTOGRAPHIC_ALGORITHM
+            )
+        else:
+            raise TypeError(
+                "cryptographic algorithm must be a CryptographicAlgorithm "
+                "enumeration"
+            )
+
+    @property
+    def random_iv(self):
+        if self._random_iv:
+            return self._random_iv.value
+        else:
+            return None
+
+    @random_iv.setter
+    def random_iv(self, value):
+        if value is None:
+            self._random_iv = None
+        elif isinstance(value, bool):
+            self._random_iv = Boolean(
+                value=value,
+                tag=Tags.RANDOM_IV
+            )
+        else:
+            raise TypeError("random iv must be a boolean")
+
+    @property
+    def iv_length(self):
+        if self._iv_length:
+            return self._iv_length.value
+        else:
+            return None
+
+    @iv_length.setter
+    def iv_length(self, value):
+        if value is None:
+            self._iv_length = None
+        elif isinstance(value, six.integer_types):
+            self._iv_length = Integer(
+                value=value,
+                tag=Tags.IV_LENGTH
+            )
+        else:
+            raise TypeError("iv length must be an integer")
+
+    @property
+    def tag_length(self):
+        if self._tag_length:
+            return self._tag_length.value
+        else:
+            return None
+
+    @tag_length.setter
+    def tag_length(self, value):
+        if value is None:
+            self._tag_length = None
+        elif isinstance(value, six.integer_types):
+            self._tag_length = Integer(
+                value=value,
+                tag=Tags.TAG_LENGTH
+            )
+        else:
+            raise TypeError("tag length must be an integer")
+
+    @property
+    def fixed_field_length(self):
+        if self._fixed_field_length:
+            return self._fixed_field_length.value
+        else:
+            return None
+
+    @fixed_field_length.setter
+    def fixed_field_length(self, value):
+        if value is None:
+            self._fixed_field_length = None
+        elif isinstance(value, six.integer_types):
+            self._fixed_field_length = Integer(
+                value=value,
+                tag=Tags.FIXED_FIELD_LENGTH
+            )
+        else:
+            raise TypeError("fixed field length must be an integer")
+
+    @property
+    def invocation_field_length(self):
+        if self._invocation_field_length:
+            return self._invocation_field_length.value
+        else:
+            return None
+
+    @invocation_field_length.setter
+    def invocation_field_length(self, value):
+        if value is None:
+            self._invocation_field_length = None
+        elif isinstance(value, six.integer_types):
+            self._invocation_field_length = Integer(
+                value=value,
+                tag=Tags.INVOCATION_FIELD_LENGTH
+            )
+        else:
+            raise TypeError("invocation field length must be an integer")
+
+    @property
+    def counter_length(self):
+        if self._counter_length:
+            return self._counter_length.value
+        else:
+            return None
+
+    @counter_length.setter
+    def counter_length(self, value):
+        if value is None:
+            self._counter_length = None
+        elif isinstance(value, six.integer_types):
+            self._counter_length = Integer(
+                value=value,
+                tag=Tags.COUNTER_LENGTH
+            )
+        else:
+            raise TypeError("counter length must be an integer")
+
+    @property
+    def initial_counter_value(self):
+        if self._initial_counter_value:
+            return self._initial_counter_value.value
+        else:
+            return None
+
+    @initial_counter_value.setter
+    def initial_counter_value(self, value):
+        if value is None:
+            self._initial_counter_value = None
+        elif isinstance(value, six.integer_types):
+            self._initial_counter_value = Integer(
+                value=value,
+                tag=Tags.INITIAL_COUNTER_VALUE
+            )
+        else:
+            raise TypeError("initial counter value must be an integer")
 
     def read(self, istream):
         super(CryptographicParameters, 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 = Enumeration(
-            self.block_cipher_mode.read(tstream)
+                enums.BlockCipherMode,
+                tag=Tags.BLOCK_CIPHER_MODE
+            )
+            self._block_cipher_mode.read(tstream)
 
         if self.is_tag_next(Tags.PADDING_METHOD, tstream):
-            self.padding_method = CryptographicParameters.PaddingMethod()
+            self._padding_method = Enumeration(
-            self.padding_method.read(tstream)
+                enums.PaddingMethod,
+                tag=Tags.PADDING_METHOD
+            )
+            self._padding_method.read(tstream)
 
         if self.is_tag_next(Tags.HASHING_ALGORITHM, tstream):
-            self.hashing_algorithm = HashingAlgorithm()
+            self._hashing_algorithm = Enumeration(
-            self.hashing_algorithm.read(tstream)
+                enums.HashingAlgorithm,
+                tag=Tags.HASHING_ALGORITHM
+            )
+            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 = Enumeration(
-            self.key_role_type.read(tstream)
+                enums.KeyRoleType,
+                tag=Tags.KEY_ROLE_TYPE
+            )
+            self._key_role_type.read(tstream)
 
         if self.is_tag_next(Tags.DIGITAL_SIGNATURE_ALGORITHM, tstream):
-            self.digital_signature_algorithm = \
+            self._digital_signature_algorithm = Enumeration(
-                CryptographicParameters.DigitalSignatureAlgorithm()
+                enums.DigitalSignatureAlgorithm,
-            self.digital_signature_algorithm.read(tstream)
+                tag=Tags.DIGITAL_SIGNATURE_ALGORITHM
+            )
+            self._digital_signature_algorithm.read(tstream)
 
         if self.is_tag_next(Tags.CRYPTOGRAPHIC_ALGORITHM, tstream):
-            self.cryptographic_algorithm = CryptographicAlgorithm()
+            self._cryptographic_algorithm = Enumeration(
-            self.cryptographic_algorithm.read(tstream)
+                enums.CryptographicAlgorithm,
+                tag=Tags.CRYPTOGRAPHIC_ALGORITHM
+            )
+            self._cryptographic_algorithm.read(tstream)
+
+        if self.is_tag_next(Tags.RANDOM_IV, tstream):
+            self._random_iv = Boolean(tag=Tags.RANDOM_IV)
+            self._random_iv.read(tstream)
+
+        if self.is_tag_next(Tags.IV_LENGTH, tstream):
+            self._iv_length = Integer(tag=Tags.IV_LENGTH)
+            self._iv_length.read(tstream)
+
+        if self.is_tag_next(Tags.TAG_LENGTH, tstream):
+            self._tag_length = Integer(tag=Tags.TAG_LENGTH)
+            self._tag_length.read(tstream)
+
+        if self.is_tag_next(Tags.FIXED_FIELD_LENGTH, tstream):
+            self._fixed_field_length = Integer(tag=Tags.FIXED_FIELD_LENGTH)
+            self._fixed_field_length.read(tstream)
+
+        if self.is_tag_next(Tags.INVOCATION_FIELD_LENGTH, tstream):
+            self._invocation_field_length = Integer(
+                tag=Tags.INVOCATION_FIELD_LENGTH
+            )
+            self._invocation_field_length.read(tstream)
+
+        if self.is_tag_next(Tags.COUNTER_LENGTH, tstream):
+            self._counter_length = Integer(tag=Tags.COUNTER_LENGTH)
+            self._counter_length.read(tstream)
+
+        if self.is_tag_next(Tags.INITIAL_COUNTER_VALUE, tstream):
+            self._initial_counter_value = Integer(
+                tag=Tags.INITIAL_COUNTER_VALUE
+            )
+            self._initial_counter_value.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:
-        if self.block_cipher_mode is not None:
+            self._block_cipher_mode.write(tstream)
-            self.block_cipher_mode.write(tstream)
+        if self._padding_method:
-        if self.padding_method is not None:
+            self._padding_method.write(tstream)
-            self.padding_method.write(tstream)
+        if self._hashing_algorithm:
-        if self.hashing_algorithm is not None:
+            self._hashing_algorithm.write(tstream)
-            self.hashing_algorithm.write(tstream)
+        if self._key_role_type:
-        if self.key_role_type is not None:
+            self._key_role_type.write(tstream)
-            self.key_role_type.write(tstream)
+        if self._digital_signature_algorithm:
-        if self.digital_signature_algorithm is not None:
+            self._digital_signature_algorithm.write(tstream)
-            self.digital_signature_algorithm.write(tstream)
+        if self._cryptographic_algorithm:
-        if self.cryptographic_algorithm is not None:
+            self._cryptographic_algorithm.write(tstream)
-            self.cryptographic_algorithm.write(tstream)
+        if self._random_iv:
+            self._random_iv.write(tstream)
+        if self._iv_length:
+            self._iv_length.write(tstream)
+        if self._tag_length:
+            self._tag_length.write(tstream)
+        if self._fixed_field_length:
+            self._fixed_field_length.write(tstream)
+        if self._invocation_field_length:
+            self._invocation_field_length.write(tstream)
+        if self._counter_length:
+            self._counter_length.write(tstream)
+        if self._initial_counter_value:
+            self._initial_counter_value.write(tstream)
 
-        # Write the length and value of the request payload
         self.length = tstream.length()
         super(CryptographicParameters, self).write(ostream)
         ostream.write(tstream.buffer)
 
-    def validate(self):
-        self.__validate()
-
-    def __validate(self):
-        if self.block_cipher_mode is not None:
-            if not isinstance(self.block_cipher_mode, self.BlockCipherMode):
-                msg = "Invalid block cipher mode"
-                msg += "; expected {0}, received {1}".format(
-                    self.BlockCipherMode, self.block_cipher_mode)
-                raise TypeError(msg)
-        if self.padding_method is not None:
-            if not isinstance(self.padding_method, self.PaddingMethod):
-                msg = "Invalid padding method"
-                msg += "; expected {0}, received {1}".format(
-                    self.PaddingMethod, self.padding_method)
-                raise TypeError(msg)
-        if self.hashing_algorithm is not None:
-            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 self.key_role_type is not None:
-            if not isinstance(self.key_role_type, self.KeyRoleType):
-                msg = "Invalid key role type"
-                msg += "; expected {0}, received {1}".format(
-                    self.KeyRoleType, self.key_role_type)
-                raise TypeError(msg)
-        if self.digital_signature_algorithm is not None:
-            if not isinstance(
-                self.digital_signature_algorithm,
-                CryptographicParameters.DigitalSignatureAlgorithm
-            ):
-                msg = "Invalid digital signature algorithm"
-                msg += "; expected {0}, received {1}".format(
-                    CryptographicParameters.DigitalSignatureAlgorithm,
-                    self.digital_signature_algorithm)
-                raise TypeError(msg)
-        if self.cryptographic_algorithm is not None:
-            if not isinstance(self.cryptographic_algorithm,
-                              CryptographicAlgorithm):
-                msg = "Invalid cryptograhic algorithm"
-                msg += "; expected {0}, received {1}".format(
-                    CryptographicAlgorithm, self.cryptographic_algorithm)
-                raise TypeError(msg)
-
     def __eq__(self, other):
         if isinstance(other, CryptographicParameters):
             if self.block_cipher_mode != other.block_cipher_mode:
                 return False
-            elif self.key_role_type != other.key_role_type:
+            elif self.padding_method != other.padding_method:
                 return False
             elif self.hashing_algorithm != other.hashing_algorithm:
                 return False
+            elif self.key_role_type != other.key_role_type:
+                return False
             elif self.digital_signature_algorithm \
                     != other.digital_signature_algorithm:
                 return False
             elif self.cryptographic_algorithm != other.cryptographic_algorithm:
                 return False
-            elif self.padding_method != other.padding_method:
+            elif self.random_iv != other.random_iv:
+                return False
+            elif self.iv_length != other.iv_length:
+                return False
+            elif self.tag_length != other.tag_length:
+                return False
+            elif self.fixed_field_length != other.fixed_field_length:
+                return False
+            elif self.invocation_field_length != other.invocation_field_length:
+                return False
+            elif self.counter_length != other.counter_length:
+                return False
+            elif self.initial_counter_value != other.initial_counter_value:
                 return False
             else:
                 return True
@@ -422,6 +730,47 @@ class CryptographicParameters(Struct):
         else:
             return NotImplemented
 
+    def __repr__(self):
+        args = ", ".join([
+            "block_cipher_mode={0}".format(self.block_cipher_mode),
+            "padding_method={0}".format(self.padding_method),
+            "hashing_algorithm={0}".format(self.hashing_algorithm),
+            "key_role_type={0}".format(self.key_role_type),
+            "digital_signature_algorithm={0}".format(
+                self.digital_signature_algorithm
+            ),
+            "cryptographic_algorithm={0}".format(
+                self.cryptographic_algorithm
+            ),
+            "random_iv={0}".format(self.random_iv),
+            "iv_length={0}".format(self.iv_length),
+            "tag_length={0}".format(self.tag_length),
+            "fixed_field_length={0}".format(self.fixed_field_length),
+            "invocation_field_length={0}".format(
+                self.invocation_field_length
+            ),
+            "counter_length={0}".format(self.counter_length),
+            "initial_counter_value={0}".format(self.initial_counter_value)
+        ])
+        return "CryptographicParameters({0})".format(args)
+
+    def __str__(self):
+        return str({
+            'block_cipher_mode': self.block_cipher_mode,
+            'padding_method': self.padding_method,
+            'hashing_algorithm': self.hashing_algorithm,
+            'key_role_type': self.key_role_type,
+            'digital_signature_algorithm': self.digital_signature_algorithm,
+            'cryptographic_algorithm': self.cryptographic_algorithm,
+            'random_iv': self.random_iv,
+            'iv_length': self.iv_length,
+            'tag_length': self.tag_length,
+            'fixed_field_length': self.fixed_field_length,
+            'invocation_field_length': self.invocation_field_length,
+            'counter_length': self.counter_length,
+            'initial_counter_value': self.initial_counter_value
+        })
+
 
 class CertificateType(Enumeration):
     """

kmip/core/factories/attribute_values.py

@@ -136,52 +136,39 @@ class AttributeValueFactory(object):
         return attributes.CryptographicLength(length)
 
     def _create_cryptographic_parameters(self, params):
-        bcm = None
+        if params is None:
-        padding_method = None
+            params = {}
-        hashing_algorithm = None
-        key_role_type = None
-        digital_signature_algorithm = None
-        cryptographic_algorithm = None
-        # TODO: Need to implement other fields of CryptographicParameters (3.6)
 
-        if params is not None:
+        if isinstance(params, dict):
-
+            return attributes.CryptographicParameters(
-            if 'block_cipher_mode' in params:
+                block_cipher_mode=params.get('block_cipher_mode', None),
-                bcm = attributes.CryptographicParameters.BlockCipherMode(
+                padding_method=params.get('padding_method', None),
-                    params.get('block_cipher_mode'))
+                hashing_algorithm=params.get('hashing_algorithm', None),
-
+                key_role_type=params.get('key_role_type', None),
-            padding_method = None
+                digital_signature_algorithm=params.get(
-            if 'padding_method' in params:
+                    'digital_signature_algorithm',
-                padding_method = attributes.CryptographicParameters. \
+                    None
-                    PaddingMethod(params.get('padding_method'))
+                ),
-
+                cryptographic_algorithm=params.get(
-            key_role_type = None
+                    'cryptographic_algorithm',
-            if 'key_role_type' in params:
+                    None
-                key_role_type = attributes.CryptographicParameters.KeyRoleType(
+                ),
-                    params.get('key_role_type'))
+                random_iv=params.get('random_iv', None),
-
+                iv_length=params.get('iv_length', None),
-            hashing_algorithm = None
+                tag_length=params.get('tag_length', None),
-            if 'hashing_algorithm' in params:
+                fixed_field_length=params.get('fixed_field_length', None),
-                hashing_algorithm = attributes.HashingAlgorithm(
+                invocation_field_length=params.get(
-                    params.get("hashing_algorithm"))
+                    'invocation_field_length',
-
+                    None
-            if 'digital_signature_algorithm' in params:
+                ),
-                digital_signature_algorithm = \
+                counter_length=params.get('counter_length', None),
-                    attributes.CryptographicParameters. \
+                initial_counter_value=params.get(
-                    DigitalSignatureAlgorithm(
+                    'initial_counter_value',
-                        params.get("digital_signature_algorithm"))
+                    None
-
+                )
-            if 'cryptographic_algorithm' in params:
+            )
-                cryptographic_algorithm = attributes.CryptographicAlgorithm(
+        else:
-                    params.get("cryptographic_algorithm"))
+            raise TypeError("cryptographic parameters must be a dict")
-
-        return attributes.CryptographicParameters(
-            block_cipher_mode=bcm,
-            padding_method=padding_method,
-            hashing_algorithm=hashing_algorithm,
-            key_role_type=key_role_type,
-            digital_signature_algorithm=digital_signature_algorithm,
-            cryptographic_algorithm=cryptographic_algorithm)
 
     def _create_cryptographic_usage_mask(self, flags):
         mask = None

kmip/pie/client.py

@@ -22,8 +22,7 @@ from kmip.core import objects as cobjects
 
 from kmip.core.factories import attributes
 
-from kmip.core.attributes import CryptographicParameters, \
+from kmip.core.attributes import CryptographicParameters
-    CryptographicAlgorithm
 
 from kmip.pie import api
 from kmip.pie import exceptions
@@ -687,7 +686,8 @@ class ProxyKmipClient(api.KmipClient):
             raise exceptions.ClientConnectionNotOpen()
 
         parameters_attribute = CryptographicParameters(
-            cryptographic_algorithm=CryptographicAlgorithm(algorithm))
+            cryptographic_algorithm=algorithm
+        )
 
         # Get the message authentication code and handle the results
         result = self.proxy.mac(data, uid, parameters_attribute)

kmip/services/server/engine.py

@@ -1700,7 +1700,7 @@ class KmipEngine(object):
         if (payload.cryptographic_parameters and
                 payload.cryptographic_parameters.cryptographic_algorithm):
             algorithm = \
-                payload.cryptographic_parameters.cryptographic_algorithm.value
+                payload.cryptographic_parameters.cryptographic_algorithm
         elif (isinstance(managed_object, objects.Key) and
               managed_object.cryptographic_algorithm):
             algorithm = managed_object.cryptographic_algorithm

kmip/tests/unit/core/factories/test_attribute_values.py

@@ -93,35 +93,55 @@ class TestAttributeValueFactory(testtools.TestCase):
             'digital_signature_algorithm':
                 enums.DigitalSignatureAlgorithm.ECDSA_WITH_SHA512,
             'cryptographic_algorithm':
-                enums.CryptographicAlgorithm.HMAC_SHA512}
+                enums.CryptographicAlgorithm.HMAC_SHA512,
-        params = self.factory.create_attribute_value(
+            'random_iv': True,
-            enums.AttributeType.CRYPTOGRAPHIC_PARAMETERS, value)
+            'iv_length': 96,
+            'tag_length': None,
+            'fixed_field_length': 32,
+            'invocation_field_length': 64,
+            'counter_length': None,
+            'initial_counter_value': 1
+        }
+        cryptographic_parameters = self.factory.create_attribute_value(
+            enums.AttributeType.CRYPTOGRAPHIC_PARAMETERS,
+            value
+        )
 
-        # TODO (peter-hamilton): Update assertEquals after structure changes
+        self.assertIsInstance(
-        self.assertIsInstance(params, attributes.CryptographicParameters)
+            cryptographic_parameters,
+            attributes.CryptographicParameters
+        )
         self.assertEqual(
-            attributes.CryptographicParameters.BlockCipherMode(
+            enums.BlockCipherMode.NIST_KEY_WRAP,
-                enums.BlockCipherMode.NIST_KEY_WRAP),
+            cryptographic_parameters.block_cipher_mode
-            params.block_cipher_mode)
+        )
         self.assertEqual(
-            attributes.CryptographicParameters.PaddingMethod(
+            enums.PaddingMethod.ANSI_X9_23,
-                enums.PaddingMethod.ANSI_X9_23),
+            cryptographic_parameters.padding_method
-            params.padding_method)
+        )
         self.assertEqual(
-            attributes.CryptographicParameters.KeyRoleType(
+            enums.KeyRoleType.KEK,
-                enums.KeyRoleType.KEK),
+            cryptographic_parameters.key_role_type
-            params.key_role_type)
+        )
         self.assertEqual(
-            attributes.HashingAlgorithm(enums.HashingAlgorithm.SHA_512),
+            enums.HashingAlgorithm.SHA_512,
-            params.hashing_algorithm)
+            cryptographic_parameters.hashing_algorithm
+        )
         self.assertEqual(
-            attributes.CryptographicParameters.DigitalSignatureAlgorithm(
+            enums.DigitalSignatureAlgorithm.ECDSA_WITH_SHA512,
-                enums.DigitalSignatureAlgorithm.ECDSA_WITH_SHA512),
+            cryptographic_parameters.digital_signature_algorithm
-            params.digital_signature_algorithm)
+        )
         self.assertEqual(
-            attributes.CryptographicAlgorithm(
+            enums.CryptographicAlgorithm.HMAC_SHA512,
-                enums.CryptographicAlgorithm.HMAC_SHA512),
+            cryptographic_parameters.cryptographic_algorithm
-            params.cryptographic_algorithm)
+        )
+        self.assertEqual(True, cryptographic_parameters.random_iv)
+        self.assertEqual(96, cryptographic_parameters.iv_length)
+        self.assertEqual(None, cryptographic_parameters.tag_length)
+        self.assertEqual(32, cryptographic_parameters.fixed_field_length)
+        self.assertEqual(64, cryptographic_parameters.invocation_field_length)
+        self.assertEqual(None, cryptographic_parameters.counter_length)
+        self.assertEqual(1, cryptographic_parameters.initial_counter_value)
 
     def test_create_cryptographic_domain_parameters(self):
         """

kmip/tests/unit/core/messages/payloads/test_mac.py

@@ -31,8 +31,8 @@ class TestMACRequestPayload(TestCase):
         self.unique_identifier = attributes.UniqueIdentifier(value='1')
         self.cryptographic_parameters = \
             attributes.CryptographicParameters(
-                cryptographic_algorithm=attributes.CryptographicAlgorithm(
+                cryptographic_algorithm=enums.CryptographicAlgorithm.
-                    enums.CryptographicAlgorithm.HMAC_SHA512)
+                HMAC_SHA512
             )
         self.data = objects.Data(
             value=(b'\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B'

kmip/tests/unit/core/messages/test_messages.py

@@ -1077,13 +1077,13 @@ class TestRequestMessage(TestCase):
         cryptographic_algorithm = parameters_attribute.cryptographic_algorithm
         msg = "Bad cryptographic algorithm type: expected {0}, received {1}"
         self.assertIsInstance(cryptographic_algorithm,
-                              attr.CryptographicAlgorithm,
+                              enums.CryptographicAlgorithm,
-                              msg.format(attr.CryptographicAlgorithm,
+                              msg.format(enums.CryptographicAlgorithm,
                                          type(cryptographic_algorithm)))
         msg = "Bad cryptographic algorithm value: expected {0}, received {1}"
-        self.assertEquals(cryptographic_algorithm.value,
+        self.assertEquals(cryptographic_algorithm,
                           enums.CryptographicAlgorithm.HMAC_SHA512,
-                          msg.format(cryptographic_algorithm.value,
+                          msg.format(cryptographic_algorithm,
                                      enums.CryptographicAlgorithm.HMAC_SHA512))
 
         data = request_payload.data
@@ -1114,8 +1114,7 @@ class TestRequestMessage(TestCase):
                    b'\x0C\x0D\x0E\x0F')
         )
         parameters_attribute = attr.CryptographicParameters(
-            cryptographic_algorithm=attr.
+            cryptographic_algorithm=enums.CryptographicAlgorithm.HMAC_SHA512
-            CryptographicAlgorithm(enums.CryptographicAlgorithm.HMAC_SHA512)
         )
         request_payload = mac.MACRequestPayload(
             unique_identifier=uuid,

kmip/tests/unit/services/server/test_engine.py

@@ -5157,8 +5157,7 @@ class TestKmipEngine(testtools.TestCase):
         uuid = str(obj.unique_identifier)
 
         cryptographic_parameters = attributes.CryptographicParameters(
-            cryptographic_algorithm=attributes.
+            cryptographic_algorithm=algorithm_b
-            CryptographicAlgorithm(algorithm_b)
         )
 
         # Verify when cryptographic_parameters is specified in request
@@ -5226,8 +5225,8 @@ class TestKmipEngine(testtools.TestCase):
         uuid_no_algorithm = str(obj_no_algorithm.unique_identifier)
 
         cryptographic_parameters = attributes.CryptographicParameters(
-            cryptographic_algorithm=attributes.
+            cryptographic_algorithm=algorithm
-            CryptographicAlgorithm(algorithm))
+        )
 
         payload_no_key = mac.MACRequestPayload(
             unique_identifier=attributes.UniqueIdentifier(uuid_no_key),
@@ -5303,8 +5302,7 @@ class TestKmipEngine(testtools.TestCase):
         uuid = str(obj.unique_identifier)
 
         cryptographic_parameters = attributes.CryptographicParameters(
-            cryptographic_algorithm=attributes.
+            cryptographic_algorithm=algorithm_b
-            CryptographicAlgorithm(algorithm_b)
         )
 
         # Verify when cryptographic_parameters is specified in request
@@ -5352,8 +5350,7 @@ class TestKmipEngine(testtools.TestCase):
         uuid = str(obj.unique_identifier)
 
         cryptographic_parameters = attributes.CryptographicParameters(
-            cryptographic_algorithm=attributes.
+            cryptographic_algorithm=algorithm_b
-            CryptographicAlgorithm(algorithm_b)
         )
 
         # Verify when cryptographic_parameters is specified in request

kmip/tests/unit/services/test_kmip_client.py

@@ -16,8 +16,7 @@
 from testtools import TestCase
 
 from kmip.core.attributes import PrivateKeyUniqueIdentifier
-from kmip.core.attributes import CryptographicParameters, \
+from kmip.core.attributes import CryptographicParameters
-                                 CryptographicAlgorithm
 
 
 from kmip.core.enums import AuthenticationSuite
@@ -786,8 +785,7 @@ class TestKMIPClient(TestCase):
         uuid = '1'
 
         cryptographic_parameters = CryptographicParameters(
-            cryptographic_algorithm=CryptographicAlgorithm(
+            cryptographic_algorithm=CryptographicAlgorithmEnum.HMAC_SHA512
-                CryptographicAlgorithmEnum.HMAC_SHA512)
         )
 
         self.client._send_message.side_effect = verify_request