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

Merge pull request #382 from OpenKMIP/feat/remove-key-factory 

Remove dead KeyFactory code
This commit is contained in:
Peter Hamilton 2017-12-08 11:07:56 -05:00 committed by GitHub
parent 637f358db7 187ed7e924
commit db7c56b37c
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
4 changed files with 0 additions and 240 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

132
kmip/core/factories/keys.py
View File

@ -1,132 +0,0 @@
# 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.enums import KeyFormatType
from kmip.core.keys import ECPrivateKey
from kmip.core.keys import OpaqueKey
from kmip.core.keys import PKCS1Key
from kmip.core.keys import PKCS8Key
from kmip.core.keys import RawKey
from kmip.core.keys import TransparentSymmetricKey
from kmip.core.keys import X509Key
class KeyFactory(object):
def create_key(self, key_format, value=None):
if value is None:
value = {}
# Switch on the format type of the key
if key_format is KeyFormatType.RAW:
return self._create_raw_key(value)
elif key_format is KeyFormatType.OPAQUE:
return self._create_opaque_key()
elif key_format is KeyFormatType.PKCS_1:
return self._create_pkcs_1_key()
elif key_format is KeyFormatType.PKCS_8:
return self._create_pkcs_8_key()
elif key_format is KeyFormatType.X_509:
return self._create_x_509_key()
elif key_format is KeyFormatType.EC_PRIVATE_KEY:
return self._create_ec_private_key()
elif key_format is KeyFormatType.TRANSPARENT_SYMMETRIC_KEY:
return self._create_transparent_symmetric_key()
elif key_format is KeyFormatType.TRANSPARENT_DSA_PRIVATE_KEY:
return self._create_transparent_dsa_private_key(value)
elif key_format is KeyFormatType.TRANSPARENT_DSA_PUBLIC_KEY:
return self._create_transparent_dsa_public_key(value)
elif key_format is KeyFormatType.TRANSPARENT_RSA_PRIVATE_KEY:
return self._create_transparent_rsa_private_key(value)
elif key_format is KeyFormatType.TRANSPARENT_RSA_PUBLIC_KEY:
return self._create_transparent_rsa_public_key(value)
elif key_format is KeyFormatType.TRANSPARENT_DH_PRIVATE_KEY:
return self._create_transparent_dh_private_key(value)
elif key_format is KeyFormatType.TRANSPARENT_DH_PUBLIC_KEY:
return self._create_transparent_dh_public_key(value)
elif key_format is KeyFormatType.TRANSPARENT_ECDSA_PRIVATE_KEY:
return self._create_transparent_ecdsa_private_key(value)
elif key_format is KeyFormatType.TRANSPARENT_ECDSA_PUBLIC_KEY:
return self._create_transparent_ecdsa_public_key(value)
elif key_format is KeyFormatType.TRANSPARENT_ECDH_PRIVATE_KEY:
return self._create_transparent_ecdh_private_key(value)
elif key_format is KeyFormatType.TRANSPARENT_ECDH_PUBLIC_KEY:
return self._create_transparent_ecdh_public_key(value)
elif key_format is KeyFormatType.TRANSPARENT_ECMQV_PRIVATE_KEY:
return self._create_transparent_ecmqv_private_key(value)
elif key_format is KeyFormatType.TRANSPARENT_ECMQV_PUBLIC_KEY:
return self._create_transparent_ecmqv_public_key(value)
else:
msg = 'Unrecognized key format type: {0}'
raise ValueError(msg.format(key_format))
def _create_raw_key(self, value):
data = value.get('bytes')
return RawKey(data)
def _create_opaque_key(self):
return OpaqueKey()
def _create_pkcs_1_key(self):
return PKCS1Key()
def _create_pkcs_8_key(self):
return PKCS8Key()
def _create_x_509_key(self):
return X509Key()
def _create_ec_private_key(self):
return ECPrivateKey()
def _create_transparent_symmetric_key(self):
return TransparentSymmetricKey()
def _create_transparent_dsa_private_key(self, value):
raise NotImplementedError()
def _create_transparent_dsa_public_key(self, value):
raise NotImplementedError()
def _create_transparent_rsa_private_key(self, value):
raise NotImplementedError()
def _create_transparent_rsa_public_key(self, value):
raise NotImplementedError()
def _create_transparent_dh_private_key(self, value):
raise NotImplementedError()
def _create_transparent_dh_public_key(self, value):
raise NotImplementedError()
def _create_transparent_ecdsa_private_key(self, value):
raise NotImplementedError()
def _create_transparent_ecdsa_public_key(self, value):
raise NotImplementedError()
def _create_transparent_ecdh_private_key(self, value):
raise NotImplementedError()
def _create_transparent_ecdh_public_key(self, value):
raise NotImplementedError()
def _create_transparent_ecmqv_private_key(self, value):
raise NotImplementedError()
def _create_transparent_ecmqv_public_key(self, value):
raise NotImplementedError()

4
kmip/core/factories/secrets.py
View File

@ -13,8 +13,6 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
from kmip.core.factories.keys import KeyFactory
from kmip.core.attributes import CryptographicAlgorithm from kmip.core.attributes import CryptographicAlgorithm
from kmip.core.attributes import CryptographicLength from kmip.core.attributes import CryptographicLength
@ -43,8 +41,6 @@ from kmip.core import utils
class SecretFactory(object): class SecretFactory(object):
def __init__(self): def __init__(self):
self.key_factory = KeyFactory()
self.base_error = ErrorStrings.BAD_EXP_RECV self.base_error = ErrorStrings.BAD_EXP_RECV
self.template_input = self.base_error.format('Template', '{0}', '{1}', self.template_input = self.base_error.format('Template', '{0}', '{1}',
'{2}') '{2}')

102
kmip/core/keys.py
View File

@ -1,102 +0,0 @@
# 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.
# This module defines classes representing all of the different key types
# used by KMIP, including the more detailed structures of the Transparent
# Keys defined in Section 2.1.7.
from kmip.core.enums import Tags
from kmip.core.primitives import Struct
from kmip.core.primitives import ByteString
from kmip.core.utils import BytearrayStream
class RawKey(ByteString):
def __init__(self, value=None):
super(RawKey, self).__init__(value, Tags.KEY_MATERIAL)
class OpaqueKey(ByteString):
def __init__(self, value=None):
super(OpaqueKey, self).__init__(value, Tags.KEY_MATERIAL)
class PKCS1Key(ByteString):
def __init__(self, value=None):
super(PKCS1Key, self).__init__(value, Tags.KEY_MATERIAL)
class PKCS8Key(ByteString):
def __init__(self, value=None):
super(PKCS8Key, self).__init__(value, Tags.KEY_MATERIAL)
class X509Key(ByteString):
def __init__(self, value=None):
super(X509Key, self).__init__(value, Tags.KEY_MATERIAL)
class ECPrivateKey(ByteString):
def __init__(self, value=None):
super(ECPrivateKey, self).__init__(value, Tags.KEY_MATERIAL)
# 2.1.7.1
class TransparentSymmetricKey(Struct):
class Key(ByteString):
def __init__(self, value=None):
super(TransparentSymmetricKey.Key, self).__init__(value, Tags.KEY)
def __init__(self, key=None):
super(TransparentSymmetricKey, self).__init__(Tags.KEY_MATERIAL)
self.key = key
self.validate()
def read(self, istream):
super(TransparentSymmetricKey, self).read(istream)
tstream = BytearrayStream(istream.read(self.length))
self.key = TransparentSymmetricKey.Key()
self.key.read(tstream)
self.is_oversized(tstream)
self.validate()
def write(self, ostream):
tstream = BytearrayStream()
self.key.write(tstream)
# Write the length and value of the key wrapping data
self.length = tstream.length()
super(TransparentSymmetricKey, self).write(ostream)
ostream.write(tstream.buffer)
def validate(self):
self.__validate()
def __validate(self):
# TODO (peter-hamilton) Finish implementation.
pass

2
kmip/tests/unit/core/messages/test_messages.py
View File

@ -16,7 +16,6 @@
from testtools import TestCase from testtools import TestCase
import binascii import binascii
from kmip.core.factories.keys import KeyFactory
from kmip.core.factories.secrets import SecretFactory from kmip.core.factories.secrets import SecretFactory
from kmip.core.factories.attributes import AttributeFactory from kmip.core.factories.attributes import AttributeFactory
@ -1144,7 +1143,6 @@ class TestResponseMessage(TestCase):
def setUp(self): def setUp(self):
super(TestResponseMessage, self).setUp() super(TestResponseMessage, self).setUp()
self.stream = BytearrayStream() self.stream = BytearrayStream()
self.key_factory = KeyFactory()
self.secret_factory = SecretFactory() self.secret_factory = SecretFactory()
self.msg = errors.ErrorStrings.BAD_EXP_RECV self.msg = errors.ErrorStrings.BAD_EXP_RECV
self.create = ( self.create = (