mirror of https://github.com/OpenKMIP/PyKMIP.git
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)
|