mirror of
https://github.com/OpenKMIP/PyKMIP.git
synced 2025-06-28 01:34:23 +02:00
bc703f0757
This change makes some minor updates to the Pie key object hierarchy. It fixes the key subclasses to inherit from Key directly. It adds in support for the key format type attribute, which is required for low-level key encoding. It also improves repr and str functionality by using binascii.hexlify to represent the key values. The corresponding test suites are updated accordingly to reflect these changes.
377 lines
15 KiB
Python
377 lines
15 KiB
Python
# Copyright (c) 2015 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.
|
|
|
|
import binascii
|
|
import testtools
|
|
|
|
from kmip.core import enums
|
|
from kmip.pie import objects
|
|
|
|
|
|
class TestPublicKey(testtools.TestCase):
|
|
"""
|
|
Test suite for PublicKey.
|
|
"""
|
|
def setUp(self):
|
|
super(TestPublicKey, self).setUp()
|
|
|
|
# Key values taken from Sections 8.2 and 13.4 of the KMIP 1.1
|
|
# testing documentation.
|
|
self.bytes_1024 = (
|
|
b'\x30\x81\x9F\x30\x0D\x06\x09\x2A\x86\x48\x86\xF7\x0D\x01\x01\x01'
|
|
b'\x05\x00\x03\x81\x8D\x00\x30\x81\x89\x02\x81\x81\x00\x93\x04\x51'
|
|
b'\xC9\xEC\xD9\x4F\x5B\xB9\xDA\x17\xDD\x09\x38\x1B\xD2\x3B\xE4\x3E'
|
|
b'\xCA\x8C\x75\x39\xF3\x01\xFC\x8A\x8C\xD5\xD5\x27\x4C\x3E\x76\x99'
|
|
b'\xDB\xDC\x71\x1C\x97\xA7\xAA\x91\xE2\xC5\x0A\x82\xBD\x0B\x10\x34'
|
|
b'\xF0\xDF\x49\x3D\xEC\x16\x36\x24\x27\xE5\x8A\xCC\xE7\xF6\xCE\x0F'
|
|
b'\x9B\xCC\x61\x7B\xBD\x8C\x90\xD0\x09\x4A\x27\x03\xBA\x0D\x09\xEB'
|
|
b'\x19\xD1\x00\x5F\x2F\xB2\x65\x52\x6A\xAC\x75\xAF\x32\xF8\xBC\x78'
|
|
b'\x2C\xDE\xD2\xA5\x7F\x81\x1E\x03\xEA\xF6\x7A\x94\x4D\xE5\xE7\x84'
|
|
b'\x13\xDC\xA8\xF2\x32\xD0\x74\xE6\xDC\xEA\x4C\xEC\x9F\x02\x03\x01'
|
|
b'\x00\x01')
|
|
self.bytes_2048 = (
|
|
b'\x30\x82\x01\x0A\x02\x82\x01\x01\x00\xAB\x7F\x16\x1C\x00\x42\x49'
|
|
b'\x6C\xCD\x6C\x6D\x4D\xAD\xB9\x19\x97\x34\x35\x35\x77\x76\x00\x3A'
|
|
b'\xCF\x54\xB7\xAF\x1E\x44\x0A\xFB\x80\xB6\x4A\x87\x55\xF8\x00\x2C'
|
|
b'\xFE\xBA\x6B\x18\x45\x40\xA2\xD6\x60\x86\xD7\x46\x48\x34\x6D\x75'
|
|
b'\xB8\xD7\x18\x12\xB2\x05\x38\x7C\x0F\x65\x83\xBC\x4D\x7D\xC7\xEC'
|
|
b'\x11\x4F\x3B\x17\x6B\x79\x57\xC4\x22\xE7\xD0\x3F\xC6\x26\x7F\xA2'
|
|
b'\xA6\xF8\x9B\x9B\xEE\x9E\x60\xA1\xD7\xC2\xD8\x33\xE5\xA5\xF4\xBB'
|
|
b'\x0B\x14\x34\xF4\xE7\x95\xA4\x11\x00\xF8\xAA\x21\x49\x00\xDF\x8B'
|
|
b'\x65\x08\x9F\x98\x13\x5B\x1C\x67\xB7\x01\x67\x5A\xBD\xBC\x7D\x57'
|
|
b'\x21\xAA\xC9\xD1\x4A\x7F\x08\x1F\xCE\xC8\x0B\x64\xE8\xA0\xEC\xC8'
|
|
b'\x29\x53\x53\xC7\x95\x32\x8A\xBF\x70\xE1\xB4\x2E\x7B\xB8\xB7\xF4'
|
|
b'\xE8\xAC\x8C\x81\x0C\xDB\x66\xE3\xD2\x11\x26\xEB\xA8\xDA\x7D\x0C'
|
|
b'\xA3\x41\x42\xCB\x76\xF9\x1F\x01\x3D\xA8\x09\xE9\xC1\xB7\xAE\x64'
|
|
b'\xC5\x41\x30\xFB\xC2\x1D\x80\xE9\xC2\xCB\x06\xC5\xC8\xD7\xCC\xE8'
|
|
b'\x94\x6A\x9A\xC9\x9B\x1C\x28\x15\xC3\x61\x2A\x29\xA8\x2D\x73\xA1'
|
|
b'\xF9\x93\x74\xFE\x30\xE5\x49\x51\x66\x2A\x6E\xDA\x29\xC6\xFC\x41'
|
|
b'\x13\x35\xD5\xDC\x74\x26\xB0\xF6\x05\x02\x03\x01\x00\x01')
|
|
|
|
def tearDown(self):
|
|
super(TestPublicKey, self).tearDown()
|
|
|
|
def test_init(self):
|
|
"""
|
|
Test that a PublicKey object can be instantiated.
|
|
"""
|
|
key = objects.PublicKey(
|
|
enums.CryptographicAlgorithm.RSA, 1024, self.bytes_1024)
|
|
|
|
self.assertEqual(
|
|
key.cryptographic_algorithm, enums.CryptographicAlgorithm.RSA)
|
|
self.assertEqual(key.cryptographic_length, 1024)
|
|
self.assertEqual(key.value, self.bytes_1024)
|
|
self.assertEqual(key.key_format_type, enums.KeyFormatType.X_509)
|
|
self.assertEqual(key.cryptographic_usage_masks, list())
|
|
self.assertEqual(key.names, ['Public Key'])
|
|
|
|
def test_init_with_args(self):
|
|
"""
|
|
Test that a PublicKey object can be instantiated with all arguments.
|
|
"""
|
|
key = objects.PublicKey(
|
|
enums.CryptographicAlgorithm.RSA,
|
|
1024,
|
|
self.bytes_1024,
|
|
enums.KeyFormatType.X_509,
|
|
masks=[enums.CryptographicUsageMask.ENCRYPT,
|
|
enums.CryptographicUsageMask.DECRYPT],
|
|
name='Test Public Key')
|
|
|
|
self.assertEqual(key.cryptographic_algorithm,
|
|
enums.CryptographicAlgorithm.RSA)
|
|
self.assertEqual(key.cryptographic_length, 1024)
|
|
self.assertEqual(key.value, self.bytes_1024)
|
|
self.assertEqual(key.key_format_type, enums.KeyFormatType.X_509)
|
|
self.assertEqual(key.cryptographic_usage_masks,
|
|
[enums.CryptographicUsageMask.ENCRYPT,
|
|
enums.CryptographicUsageMask.DECRYPT])
|
|
self.assertEqual(key.names, ['Test Public Key'])
|
|
|
|
def test_get_object_type(self):
|
|
"""
|
|
Test that the object type can be retrieved from the PublicKey.
|
|
"""
|
|
expected = enums.ObjectType.PUBLIC_KEY
|
|
key = objects.PublicKey(
|
|
enums.CryptographicAlgorithm.RSA, 1024, self.bytes_1024,
|
|
enums.KeyFormatType.X_509)
|
|
observed = key.object_type
|
|
self.assertEqual(expected, observed)
|
|
|
|
def test_validate_on_invalid_algorithm(self):
|
|
"""
|
|
Test that a TypeError is raised when an invalid algorithm value is
|
|
used to construct a PublicKey.
|
|
"""
|
|
args = ('invalid', 1024, self.bytes_1024, enums.KeyFormatType.X_509)
|
|
self.assertRaises(TypeError, objects.PublicKey, *args)
|
|
|
|
def test_validate_on_invalid_length(self):
|
|
"""
|
|
Test that a TypeError is raised when an invalid length value is used
|
|
to construct a PublicKey.
|
|
"""
|
|
args = (enums.CryptographicAlgorithm.RSA, 'invalid', self.bytes_1024,
|
|
enums.KeyFormatType.X_509)
|
|
self.assertRaises(TypeError, objects.PublicKey, *args)
|
|
|
|
def test_validate_on_invalid_value(self):
|
|
"""
|
|
Test that a TypeError is raised when an invalid value is used to
|
|
construct a PublicKey.
|
|
"""
|
|
args = (enums.CryptographicAlgorithm.RSA, 1024, 0,
|
|
enums.KeyFormatType.X_509)
|
|
self.assertRaises(TypeError, objects.PublicKey, *args)
|
|
|
|
def test_validate_on_invalid_format_type(self):
|
|
"""
|
|
Test that a TypeError is raised when an invalid format type is used to
|
|
construct a PublicKey.
|
|
"""
|
|
args = (enums.CryptographicAlgorithm.RSA, 1024, self.bytes_1024,
|
|
'invalid')
|
|
self.assertRaises(TypeError, objects.PublicKey, *args)
|
|
|
|
def test_validate_on_invalid_format_type_value(self):
|
|
"""
|
|
Test that a ValueError is raised when an invalid format type is used to
|
|
construct a PublicKey.
|
|
"""
|
|
args = (enums.CryptographicAlgorithm.RSA, 1024, self.bytes_1024,
|
|
enums.KeyFormatType.OPAQUE)
|
|
self.assertRaises(ValueError, objects.PublicKey, *args)
|
|
|
|
def test_validate_on_invalid_masks(self):
|
|
"""
|
|
Test that a TypeError is raised when an invalid masks value is used to
|
|
construct a PublicKey.
|
|
"""
|
|
args = (enums.CryptographicAlgorithm.RSA, 1024, self.bytes_1024,
|
|
enums.KeyFormatType.X_509)
|
|
kwargs = {'masks': 'invalid'}
|
|
self.assertRaises(TypeError, objects.PublicKey, *args, **kwargs)
|
|
|
|
def test_validate_on_invalid_mask(self):
|
|
"""
|
|
Test that a TypeError is raised when an invalid mask value is used to
|
|
construct a PublicKey.
|
|
"""
|
|
args = (enums.CryptographicAlgorithm.RSA, 1024, self.bytes_1024,
|
|
enums.KeyFormatType.X_509)
|
|
kwargs = {'masks': ['invalid']}
|
|
self.assertRaises(TypeError, objects.PublicKey, *args, **kwargs)
|
|
|
|
def test_validate_on_invalid_name(self):
|
|
"""
|
|
Test that a TypeError is raised when an invalid name value is used to
|
|
construct a PublicKey.
|
|
"""
|
|
args = (enums.CryptographicAlgorithm.RSA, 1024, self.bytes_1024,
|
|
enums.KeyFormatType.X_509)
|
|
kwargs = {'name': 0}
|
|
self.assertRaises(TypeError, objects.PublicKey, *args, **kwargs)
|
|
|
|
def test_repr(self):
|
|
"""
|
|
Test that repr can be applied to a PublicKey.
|
|
"""
|
|
key = objects.PublicKey(
|
|
enums.CryptographicAlgorithm.RSA, 1024, self.bytes_1024,
|
|
enums.KeyFormatType.X_509)
|
|
args = "algorithm={0}, length={1}, value={2}, format_type={3}".format(
|
|
enums.CryptographicAlgorithm.RSA, 1024,
|
|
binascii.hexlify(self.bytes_1024), enums.KeyFormatType.X_509)
|
|
expected = "PublicKey({0})".format(args)
|
|
observed = repr(key)
|
|
self.assertEqual(expected, observed)
|
|
|
|
def test_str(self):
|
|
"""
|
|
Test that str can be applied to a PublicKey.
|
|
"""
|
|
key = objects.PublicKey(
|
|
enums.CryptographicAlgorithm.RSA, 1024, self.bytes_1024,
|
|
enums.KeyFormatType.X_509)
|
|
expected = str(binascii.hexlify(self.bytes_1024))
|
|
observed = str(key)
|
|
self.assertEqual(expected, observed)
|
|
|
|
def test_equal_on_equal(self):
|
|
"""
|
|
Test that the equality operator returns True when comparing two
|
|
PublicKey objects with the same data.
|
|
"""
|
|
a = objects.PublicKey(
|
|
enums.CryptographicAlgorithm.RSA, 1024, self.bytes_1024,
|
|
enums.KeyFormatType.X_509)
|
|
b = objects.PublicKey(
|
|
enums.CryptographicAlgorithm.RSA, 1024, self.bytes_1024,
|
|
enums.KeyFormatType.X_509)
|
|
self.assertTrue(a == b)
|
|
self.assertTrue(b == a)
|
|
|
|
def test_equal_on_not_equal_algorithm(self):
|
|
"""
|
|
Test that the equality operator returns False when comparing two
|
|
PublicKey objects with different data.
|
|
"""
|
|
a = objects.PublicKey(
|
|
enums.CryptographicAlgorithm.RSA, 1024, self.bytes_1024,
|
|
enums.KeyFormatType.X_509)
|
|
b = objects.PublicKey(
|
|
enums.CryptographicAlgorithm.AES, 1024, self.bytes_1024,
|
|
enums.KeyFormatType.X_509)
|
|
self.assertFalse(a == b)
|
|
self.assertFalse(b == a)
|
|
|
|
def test_equal_on_not_equal_length(self):
|
|
"""
|
|
Test that the equality operator returns False when comparing two
|
|
PublicKey objects with different data.
|
|
"""
|
|
a = objects.PublicKey(
|
|
enums.CryptographicAlgorithm.RSA, 1024, self.bytes_1024,
|
|
enums.KeyFormatType.X_509)
|
|
b = objects.PublicKey(
|
|
enums.CryptographicAlgorithm.RSA, 2048, self.bytes_1024,
|
|
enums.KeyFormatType.X_509)
|
|
self.assertFalse(a == b)
|
|
self.assertFalse(b == a)
|
|
|
|
def test_equal_on_not_equal_value(self):
|
|
"""
|
|
Test that the equality operator returns False when comparing two
|
|
PublicKey objects with different data.
|
|
"""
|
|
a = objects.PublicKey(
|
|
enums.CryptographicAlgorithm.RSA, 1024, self.bytes_1024,
|
|
enums.KeyFormatType.X_509)
|
|
b = objects.PublicKey(
|
|
enums.CryptographicAlgorithm.RSA, 1024, self.bytes_2048,
|
|
enums.KeyFormatType.X_509)
|
|
self.assertFalse(a == b)
|
|
self.assertFalse(b == a)
|
|
|
|
def test_equal_on_not_equal_format_type(self):
|
|
"""
|
|
Test that the equality operator returns False when comparing two
|
|
PublicKey objects with different data.
|
|
"""
|
|
a = objects.PublicKey(
|
|
enums.CryptographicAlgorithm.RSA, 1024, self.bytes_1024,
|
|
enums.KeyFormatType.X_509)
|
|
b = objects.PublicKey(
|
|
enums.CryptographicAlgorithm.RSA, 1024, self.bytes_1024,
|
|
enums.KeyFormatType.PKCS_1)
|
|
self.assertFalse(a == b)
|
|
self.assertFalse(b == a)
|
|
|
|
def test_equal_on_type_mismatch(self):
|
|
"""
|
|
Test that the equality operator returns False when comparing a
|
|
PublicKey object to a non-PublicKey object.
|
|
"""
|
|
a = objects.PublicKey(
|
|
enums.CryptographicAlgorithm.RSA, 1024, self.bytes_1024,
|
|
enums.KeyFormatType.X_509)
|
|
b = "invalid"
|
|
self.assertFalse(a == b)
|
|
self.assertFalse(b == a)
|
|
|
|
def test_not_equal_on_equal(self):
|
|
"""
|
|
Test that the inequality operator returns False when comparing
|
|
two PublicKey objects with the same internal data.
|
|
"""
|
|
a = objects.PublicKey(
|
|
enums.CryptographicAlgorithm.RSA, 2048, self.bytes_2048,
|
|
enums.KeyFormatType.PKCS_1)
|
|
b = objects.PublicKey(
|
|
enums.CryptographicAlgorithm.RSA, 2048, self.bytes_2048,
|
|
enums.KeyFormatType.PKCS_1)
|
|
self.assertFalse(a != b)
|
|
self.assertFalse(b != a)
|
|
|
|
def test_not_equal_on_not_equal_algorithm(self):
|
|
"""
|
|
Test that the equality operator returns True when comparing two
|
|
PublicKey objects with different data.
|
|
"""
|
|
a = objects.PublicKey(
|
|
enums.CryptographicAlgorithm.RSA, 2048, self.bytes_2048,
|
|
enums.KeyFormatType.PKCS_1)
|
|
b = objects.PublicKey(
|
|
enums.CryptographicAlgorithm.AES, 2048, self.bytes_2048,
|
|
enums.KeyFormatType.PKCS_1)
|
|
self.assertTrue(a != b)
|
|
self.assertTrue(b != a)
|
|
|
|
def test_not_equal_on_not_equal_length(self):
|
|
"""
|
|
Test that the equality operator returns True when comparing two
|
|
PublicKey objects with different data.
|
|
"""
|
|
a = objects.PublicKey(
|
|
enums.CryptographicAlgorithm.RSA, 2048, self.bytes_2048,
|
|
enums.KeyFormatType.PKCS_1)
|
|
b = objects.PublicKey(
|
|
enums.CryptographicAlgorithm.RSA, 1024, self.bytes_1024,
|
|
enums.KeyFormatType.PKCS_1)
|
|
self.assertTrue(a != b)
|
|
self.assertTrue(b != a)
|
|
|
|
def test_not_equal_on_not_equal_value(self):
|
|
"""
|
|
Test that the equality operator returns True when comparing two
|
|
PublicKey objects with different data.
|
|
"""
|
|
a = objects.PublicKey(
|
|
enums.CryptographicAlgorithm.RSA, 2048, self.bytes_2048,
|
|
enums.KeyFormatType.PKCS_1)
|
|
b = objects.PublicKey(
|
|
enums.CryptographicAlgorithm.RSA, 2048, self.bytes_1024,
|
|
enums.KeyFormatType.PKCS_1)
|
|
self.assertTrue(a != b)
|
|
self.assertTrue(b != a)
|
|
|
|
def test_not_equal_on_not_equal_format_type(self):
|
|
"""
|
|
Test that the equality operator returns True when comparing two
|
|
PublicKey objects with different data.
|
|
"""
|
|
a = objects.PublicKey(
|
|
enums.CryptographicAlgorithm.RSA, 2048, self.bytes_2048,
|
|
enums.KeyFormatType.PKCS_1)
|
|
b = objects.PublicKey(
|
|
enums.CryptographicAlgorithm.RSA, 2048, self.bytes_2048,
|
|
enums.KeyFormatType.X_509)
|
|
self.assertTrue(a != b)
|
|
self.assertTrue(b != a)
|
|
|
|
def test_not_equal_on_type_mismatch(self):
|
|
"""
|
|
Test that the equality operator returns True when comparing a
|
|
PublicKey object to a non-PublicKey object.
|
|
"""
|
|
a = objects.PublicKey(
|
|
enums.CryptographicAlgorithm.RSA, 2048, self.bytes_2048,
|
|
enums.KeyFormatType.PKCS_1)
|
|
b = "invalid"
|
|
self.assertTrue(a != b)
|
|
self.assertTrue(b != a)
|