Add created property to Managed Objects
Adds the property 'created' to managed objects in Castellan.
The property is None until the secret has been stored.
Change-Id: I83e79cd3dbc07b90f4526a36aaf4ee76e902e228
“Fernando authored 8 years ago
Fernando Diaz committed 8 years ago
| 18 | 18 | This module defines the ManagedObject class. The ManagedObject class |
| 19 | 19 | is the base class to represent all objects managed by the key manager. |
| 20 | 20 | """ |
| 21 | ||
| 22 | 21 | import abc |
| 23 | 22 | |
| 24 | 23 | import six |
| 28 | 27 | class ManagedObject(object): |
| 29 | 28 | """Base class to represent all managed objects.""" |
| 30 | 29 | |
| 31 | def __init__(self, name=None): | |
| 32 | """Managed Object has a name, defaulted to None.""" | |
| 30 | def __init__(self, name=None, created=None): | |
| 31 | """Managed Object | |
| 32 | ||
| 33 | :param name: the name of the managed object. | |
| 34 | :param created: the time a managed object was created. | |
| 35 | """ | |
| 33 | 36 | self._name = name |
| 37 | ||
| 38 | # If None or POSIX times | |
| 39 | if not created or type(created) == int: | |
| 40 | self._created = created | |
| 41 | else: | |
| 42 | raise ValueError('created must be of long type, actual type %s' % | |
| 43 | type(created)) | |
| 34 | 44 | |
| 35 | 45 | @property |
| 36 | 46 | def name(self): |
| 39 | 49 | Returns the object's name or None if this object does not have one. |
| 40 | 50 | """ |
| 41 | 51 | return self._name |
| 52 | ||
| 53 | @property | |
| 54 | def created(self): | |
| 55 | """Returns the POSIX time(long) of the object that was created. | |
| 56 | ||
| 57 | Returns the POSIX time(long) of the object that was created or None if | |
| 58 | the object does not have one, meaning it has not been persisted. | |
| 59 | """ | |
| 60 | return self._created | |
| 42 | 61 | |
| 43 | 62 | @abc.abstractproperty |
| 44 | 63 | def format(self): |
| 24 | 24 | class OpaqueData(managed_object.ManagedObject): |
| 25 | 25 | """This class represents opaque data.""" |
| 26 | 26 | |
| 27 | def __init__(self, data, name=None): | |
| 27 | def __init__(self, data, name=None, created=None): | |
| 28 | 28 | """Create a new OpaqueData object. |
| 29 | 29 | |
| 30 | 30 | Expected type for data is a bytestring. |
| 31 | 31 | """ |
| 32 | 32 | self._data = data |
| 33 | super(OpaqueData, self).__init__(name=name) | |
| 33 | super(OpaqueData, self).__init__(name=name, created=created) | |
| 34 | 34 | |
| 35 | 35 | @property |
| 36 | 36 | def format(self): |
| 43 | 43 | |
| 44 | 44 | def __eq__(self, other): |
| 45 | 45 | if isinstance(other, OpaqueData): |
| 46 | return (self._data == other._data and | |
| 47 | self._name == other._name) | |
| 46 | return (self._data == other._data) | |
| 48 | 47 | else: |
| 49 | 48 | return False |
| 50 | 49 | |
| 24 | 24 | class Passphrase(managed_object.ManagedObject): |
| 25 | 25 | """This class represents a passphrase.""" |
| 26 | 26 | |
| 27 | def __init__(self, passphrase, name=None): | |
| 27 | def __init__(self, passphrase, name=None, created=None): | |
| 28 | 28 | """Create a new Passphrase object. |
| 29 | 29 | |
| 30 | 30 | The expected type for the passphrase is a bytestring. |
| 31 | 31 | """ |
| 32 | 32 | self._passphrase = passphrase |
| 33 | super(Passphrase, self).__init__(name=name) | |
| 33 | super(Passphrase, self).__init__(name=name, created=created) | |
| 34 | 34 | |
| 35 | 35 | @property |
| 36 | 36 | def format(self): |
| 43 | 43 | |
| 44 | 44 | def __eq__(self, other): |
| 45 | 45 | if isinstance(other, Passphrase): |
| 46 | return (self._passphrase == other._passphrase and | |
| 47 | self._name == other._name) | |
| 46 | return (self._passphrase == other._passphrase) | |
| 48 | 47 | else: |
| 49 | 48 | return False |
| 50 | 49 | |
| 24 | 24 | class PrivateKey(key.Key): |
| 25 | 25 | """This class represents private keys.""" |
| 26 | 26 | |
| 27 | def __init__(self, algorithm, bit_length, key, name=None): | |
| 27 | def __init__(self, algorithm, bit_length, key, | |
| 28 | name=None, created=None): | |
| 28 | 29 | """Create a new PrivateKey object. |
| 29 | 30 | |
| 30 | 31 | The arguments specify the algorithm and bit length for the asymmetric |
| 33 | 34 | self._alg = algorithm |
| 34 | 35 | self._bit_length = bit_length |
| 35 | 36 | self._key = key |
| 36 | super(PrivateKey, self).__init__(name=name) | |
| 37 | super(PrivateKey, self).__init__(name=name, created=created) | |
| 37 | 38 | |
| 38 | 39 | @property |
| 39 | 40 | def algorithm(self): |
| 58 | 59 | if isinstance(other, PrivateKey): |
| 59 | 60 | return (self._alg == other._alg and |
| 60 | 61 | self._bit_length == other._bit_length and |
| 61 | self._key == other._key and | |
| 62 | self._name == other._name) | |
| 62 | self._key == other._key) | |
| 63 | 63 | else: |
| 64 | 64 | return False |
| 65 | 65 | |
| 24 | 24 | class PublicKey(key.Key): |
| 25 | 25 | """This class represents public keys.""" |
| 26 | 26 | |
| 27 | def __init__(self, algorithm, bit_length, key, name=None): | |
| 27 | def __init__(self, algorithm, bit_length, key, | |
| 28 | name=None, created=None): | |
| 28 | 29 | """Create a new PublicKey object. |
| 29 | 30 | |
| 30 | 31 | The arguments specify the algorithm and bit length for the asymmetric |
| 34 | 35 | self._alg = algorithm |
| 35 | 36 | self._bit_length = bit_length |
| 36 | 37 | self._key = key |
| 37 | super(PublicKey, self).__init__(name=name) | |
| 38 | super(PublicKey, self).__init__(name=name, created=created) | |
| 38 | 39 | |
| 39 | 40 | @property |
| 40 | 41 | def algorithm(self): |
| 59 | 60 | if isinstance(other, PublicKey): |
| 60 | 61 | return (self._alg == other._alg and |
| 61 | 62 | self._bit_length == other._bit_length and |
| 62 | self._key == other._key and | |
| 63 | self._name == other._name) | |
| 63 | self._key == other._key) | |
| 64 | 64 | else: |
| 65 | 65 | return False |
| 66 | 66 | |
| 24 | 24 | class SymmetricKey(key.Key): |
| 25 | 25 | """This class represents symmetric keys.""" |
| 26 | 26 | |
| 27 | def __init__(self, algorithm, bit_length, key, name=None): | |
| 27 | def __init__(self, algorithm, bit_length, key, | |
| 28 | name=None, created=None): | |
| 28 | 29 | """Create a new SymmetricKey object. |
| 29 | 30 | |
| 30 | 31 | The arguments specify the algorithm and bit length for the symmetric |
| 33 | 34 | self._alg = algorithm |
| 34 | 35 | self._bit_length = bit_length |
| 35 | 36 | self._key = key |
| 36 | super(SymmetricKey, self).__init__(name=name) | |
| 37 | super(SymmetricKey, self).__init__(name=name, created=created) | |
| 37 | 38 | |
| 38 | 39 | @property |
| 39 | 40 | def algorithm(self): |
| 58 | 59 | if isinstance(other, SymmetricKey): |
| 59 | 60 | return (self._alg == other._alg and |
| 60 | 61 | self._bit_length == other._bit_length and |
| 61 | self._key == other._key and | |
| 62 | self._name == other._name) | |
| 62 | self._key == other._key) | |
| 63 | 63 | else: |
| 64 | 64 | return False |
| 65 | 65 | |
| 24 | 24 | class X509(certificate.Certificate): |
| 25 | 25 | """This class represents X.509 certificates.""" |
| 26 | 26 | |
| 27 | def __init__(self, data, name=None): | |
| 27 | def __init__(self, data, name=None, created=None): | |
| 28 | 28 | """Create a new X509 object. |
| 29 | 29 | |
| 30 | 30 | The data should be in a bytestring. |
| 31 | 31 | """ |
| 32 | 32 | self._data = data |
| 33 | super(X509, self).__init__(name=name) | |
| 33 | super(X509, self).__init__(name=name, created=created) | |
| 34 | 34 | |
| 35 | 35 | @property |
| 36 | 36 | def format(self): |
| 43 | 43 | |
| 44 | 44 | def __eq__(self, other): |
| 45 | 45 | if isinstance(other, X509): |
| 46 | return (self._data == other._data and | |
| 47 | self._name == other._name) | |
| 46 | return (self._data == other._data) | |
| 48 | 47 | else: |
| 49 | 48 | return False |
| 50 | 49 | |
| 15 | 15 | """ |
| 16 | 16 | Key manager implementation for Barbican |
| 17 | 17 | """ |
| 18 | import calendar | |
| 18 | 19 | import time |
| 19 | 20 | |
| 20 | 21 | from cryptography.hazmat import backends |
| 39 | 40 | |
| 40 | 41 | from barbicanclient import client as barbican_client |
| 41 | 42 | from barbicanclient import exceptions as barbican_exceptions |
| 43 | from oslo_utils import timeutils | |
| 42 | 44 | from six.moves import urllib |
| 45 | ||
| 43 | 46 | |
| 44 | 47 | barbican_opts = [ |
| 45 | 48 | cfg.StrOpt('barbican_endpoint', |
| 420 | 423 | |
| 421 | 424 | secret_data = self._get_secret_data(secret) |
| 422 | 425 | |
| 426 | # convert created ISO8601 in Barbican to POSIX | |
| 427 | if secret.created: | |
| 428 | time_stamp = timeutils.parse_isotime( | |
| 429 | str(secret.created)).timetuple() | |
| 430 | created = calendar.timegm(time_stamp) | |
| 431 | ||
| 423 | 432 | if issubclass(secret_type, key_base_class.Key): |
| 424 | 433 | return secret_type(secret.algorithm, |
| 425 | 434 | secret.bit_length, |
| 426 | 435 | secret_data, |
| 427 | secret.name) | |
| 436 | secret.name, | |
| 437 | created) | |
| 428 | 438 | else: |
| 429 | 439 | return secret_type(secret_data, |
| 430 | secret.name) | |
| 440 | secret.name, | |
| 441 | created) | |
| 431 | 442 | |
| 432 | 443 | def _get_secret(self, context, object_id): |
| 433 | 444 | """Returns the metadata of the secret. |
| 15 | 15 | """ |
| 16 | 16 | Test cases for the barbican key manager. |
| 17 | 17 | """ |
| 18 | import calendar | |
| 18 | 19 | |
| 19 | 20 | from barbicanclient import exceptions as barbican_exceptions |
| 20 | 21 | import mock |
| 21 | 22 | from oslo_config import cfg |
| 23 | from oslo_utils import timeutils | |
| 22 | 24 | |
| 23 | 25 | from castellan.common import exception |
| 24 | 26 | from castellan.common.objects import symmetric_key as sym_key |
| 186 | 188 | original_secret_metadata.bit_length = mock.sentinel.bit |
| 187 | 189 | original_secret_metadata.secret_type = 'symmetric' |
| 188 | 190 | |
| 191 | created = timeutils.parse_isotime('2015-10-20 18:51:17+00:00') | |
| 192 | original_secret_metadata.created = created | |
| 193 | created_formatted = timeutils.parse_isotime(str(created)) | |
| 194 | created_posix = calendar.timegm(created_formatted.timetuple()) | |
| 195 | ||
| 189 | 196 | key_name = 'my key' |
| 190 | 197 | original_secret_metadata.name = key_name |
| 191 | 198 | |
| 198 | 205 | self.get.assert_called_once_with(self.secret_ref) |
| 199 | 206 | self.assertEqual(key_name, key.name) |
| 200 | 207 | self.assertEqual(original_secret_data, key.get_encoded()) |
| 208 | self.assertEqual(created_posix, key.created) | |
| 201 | 209 | |
| 202 | 210 | def test_get_null_context(self): |
| 203 | 211 | self.key_mgr._barbican_client = None |
| 15 | 15 | """ |
| 16 | 16 | Test cases for the opaque data class. |
| 17 | 17 | """ |
| 18 | ||
| 19 | 18 | from castellan.common.objects import opaque_data |
| 20 | 19 | from castellan.tests import base |
| 21 | 20 | |
| 23 | 22 | class OpaqueDataTestCase(base.TestCase): |
| 24 | 23 | |
| 25 | 24 | def _create_data(self): |
| 26 | return opaque_data.OpaqueData(self.data, self.name) | |
| 25 | return opaque_data.OpaqueData(self.data, | |
| 26 | self.name, | |
| 27 | self.created) | |
| 27 | 28 | |
| 28 | 29 | def setUp(self): |
| 29 | 30 | self.data = bytes(b"secret opaque data") |
| 30 | 31 | self.name = 'my opaque' |
| 32 | self.created = 1448088699 | |
| 31 | 33 | self.opaque_data = self._create_data() |
| 32 | 34 | |
| 33 | 35 | super(OpaqueDataTestCase, self).setUp() |
| 41 | 43 | def test_get_name(self): |
| 42 | 44 | self.assertEqual(self.name, self.opaque_data.name) |
| 43 | 45 | |
| 46 | def test_get_created(self): | |
| 47 | self.assertEqual(self.created, self.opaque_data.created) | |
| 48 | ||
| 49 | def test_get_created_none(self): | |
| 50 | created = None | |
| 51 | data = opaque_data.OpaqueData(self.data, | |
| 52 | self.name, | |
| 53 | created) | |
| 54 | ||
| 55 | self.assertEqual(created, data.created) | |
| 56 | ||
| 44 | 57 | def test___eq__(self): |
| 45 | 58 | self.assertTrue(self.opaque_data == self.opaque_data) |
| 46 | 59 | self.assertTrue(self.opaque_data is self.opaque_data) |
| 48 | 61 | self.assertFalse(self.opaque_data is None) |
| 49 | 62 | self.assertFalse(None == self.opaque_data) |
| 50 | 63 | |
| 51 | other_opaque_data = opaque_data.OpaqueData(self.data, self.name) | |
| 64 | other_opaque_data = opaque_data.OpaqueData(self.data) | |
| 52 | 65 | self.assertTrue(self.opaque_data == other_opaque_data) |
| 53 | 66 | self.assertFalse(self.opaque_data is other_opaque_data) |
| 54 | 67 | |
| 59 | 72 | def test___ne___data(self): |
| 60 | 73 | other_opaque = opaque_data.OpaqueData(b'other data', self.name) |
| 61 | 74 | self.assertTrue(self.opaque_data != other_opaque) |
| 62 | ||
| 63 | def test___ne___name(self): | |
| 64 | other_opaque = opaque_data.OpaqueData(self.data, "other opaque") | |
| 65 | self.assertTrue(self.opaque_data != other_opaque) | |
| 15 | 15 | """ |
| 16 | 16 | Test cases for the passphrase class. |
| 17 | 17 | """ |
| 18 | ||
| 19 | 18 | from castellan.common.objects import passphrase |
| 20 | 19 | from castellan.tests import base |
| 21 | 20 | |
| 24 | 23 | |
| 25 | 24 | def _create_passphrase(self): |
| 26 | 25 | return passphrase.Passphrase(self.passphrase_data, |
| 27 | self.name) | |
| 26 | self.name, | |
| 27 | self.created) | |
| 28 | 28 | |
| 29 | 29 | def setUp(self): |
| 30 | 30 | self.passphrase_data = bytes(b"secret passphrase") |
| 31 | 31 | self.name = 'my phrase' |
| 32 | self.created = 1448088699 | |
| 32 | 33 | self.passphrase = self._create_passphrase() |
| 33 | 34 | |
| 34 | 35 | super(PassphraseTestCase, self).setUp() |
| 42 | 43 | def test_get_name(self): |
| 43 | 44 | self.assertEqual(self.name, self.passphrase.name) |
| 44 | 45 | |
| 46 | def test_get_created(self): | |
| 47 | self.assertEqual(self.created, self.passphrase.created) | |
| 48 | ||
| 49 | def test_get_created_none(self): | |
| 50 | created = None | |
| 51 | phrase = passphrase.Passphrase(self.passphrase_data, | |
| 52 | self.name, | |
| 53 | created) | |
| 54 | ||
| 55 | self.assertEqual(created, phrase.created) | |
| 56 | ||
| 45 | 57 | def test___eq__(self): |
| 46 | 58 | self.assertTrue(self.passphrase == self.passphrase) |
| 47 | 59 | self.assertTrue(self.passphrase is self.passphrase) |
| 49 | 61 | self.assertFalse(self.passphrase is None) |
| 50 | 62 | self.assertFalse(None == self.passphrase) |
| 51 | 63 | |
| 52 | other_passphrase = passphrase.Passphrase(self.passphrase_data, | |
| 53 | self.name) | |
| 64 | other_passphrase = passphrase.Passphrase(self.passphrase_data) | |
| 54 | 65 | self.assertTrue(self.passphrase == other_passphrase) |
| 55 | 66 | self.assertFalse(self.passphrase is other_passphrase) |
| 56 | 67 | |
| 61 | 72 | def test___ne___data(self): |
| 62 | 73 | other_phrase = passphrase.Passphrase(b"other passphrase", self.name) |
| 63 | 74 | self.assertTrue(self.passphrase != other_phrase) |
| 64 | ||
| 65 | def test___ne__name(self): | |
| 66 | other_phrase = passphrase.Passphrase(self.passphrase_data, | |
| 67 | "other phrase") | |
| 68 | self.assertTrue(self.passphrase != other_phrase) | |
| 15 | 15 | """ |
| 16 | 16 | Test cases for the private key class. |
| 17 | 17 | """ |
| 18 | ||
| 19 | 18 | from castellan.common.objects import private_key |
| 20 | 19 | from castellan.tests import base |
| 21 | 20 | from castellan.tests import utils |
| 25 | 24 | |
| 26 | 25 | def _create_key(self): |
| 27 | 26 | return private_key.PrivateKey(self.algorithm, |
| 28 | self.length, | |
| 27 | self.bit_length, | |
| 29 | 28 | self.encoded, |
| 30 | self.name) | |
| 29 | self.name, | |
| 30 | self.created) | |
| 31 | 31 | |
| 32 | 32 | def setUp(self): |
| 33 | 33 | self.algorithm = 'RSA' |
| 34 | self.length = 2048 | |
| 34 | self.bit_length = 2048 | |
| 35 | 35 | self.encoded = bytes(utils.get_private_key_der()) |
| 36 | 36 | self.name = 'my key' |
| 37 | self.created = 1448088699 | |
| 37 | 38 | |
| 38 | 39 | super(PrivateKeyTestCase, self).setUp() |
| 39 | 40 | |
| 40 | 41 | def test_get_algorithm(self): |
| 41 | 42 | self.assertEqual(self.algorithm, self.key.algorithm) |
| 42 | 43 | |
| 43 | def test_get_length(self): | |
| 44 | self.assertEqual(self.length, self.key.bit_length) | |
| 44 | def test_get_bit_length(self): | |
| 45 | self.assertEqual(self.bit_length, self.key.bit_length) | |
| 45 | 46 | |
| 46 | 47 | def test_get_name(self): |
| 47 | 48 | self.assertEqual(self.name, self.key.name) |
| 52 | 53 | def test_get_encoded(self): |
| 53 | 54 | self.assertEqual(self.encoded, self.key.get_encoded()) |
| 54 | 55 | |
| 56 | def test_get_created(self): | |
| 57 | self.assertEqual(self.created, self.key.created) | |
| 58 | ||
| 59 | def test_get_created_none(self): | |
| 60 | created = None | |
| 61 | key = private_key.PrivateKey(self.algorithm, | |
| 62 | self.bit_length, | |
| 63 | self.encoded, | |
| 64 | self.name, | |
| 65 | created) | |
| 66 | ||
| 67 | self.assertEqual(created, key.created) | |
| 68 | ||
| 55 | 69 | def test___eq__(self): |
| 56 | 70 | self.assertTrue(self.key == self.key) |
| 57 | 71 | self.assertTrue(self.key is self.key) |
| 60 | 74 | self.assertFalse(None == self.key) |
| 61 | 75 | |
| 62 | 76 | other_key = private_key.PrivateKey(self.algorithm, |
| 63 | self.length, | |
| 64 | self.encoded, | |
| 65 | self.name) | |
| 77 | self.bit_length, | |
| 78 | self.encoded) | |
| 66 | 79 | self.assertTrue(self.key == other_key) |
| 67 | 80 | self.assertFalse(self.key is other_key) |
| 68 | 81 | |
| 72 | 85 | |
| 73 | 86 | def test___ne___algorithm(self): |
| 74 | 87 | other_key = private_key.PrivateKey('DSA', |
| 75 | self.length, | |
| 88 | self.bit_length, | |
| 76 | 89 | self.encoded, |
| 77 | 90 | self.name) |
| 78 | 91 | self.assertTrue(self.key != other_key) |
| 79 | 92 | |
| 80 | def test___ne___length(self): | |
| 93 | def test___ne___bit_length(self): | |
| 81 | 94 | other_key = private_key.PrivateKey(self.algorithm, |
| 82 | 95 | 4096, |
| 83 | 96 | self.encoded, |
| 87 | 100 | def test___ne___encoded(self): |
| 88 | 101 | different_encoded = bytes(utils.get_private_key_der()) + b'\x00' |
| 89 | 102 | other_key = private_key.PrivateKey(self.algorithm, |
| 90 | self.length, | |
| 103 | self.bit_length, | |
| 91 | 104 | different_encoded, |
| 92 | 105 | self.name) |
| 93 | 106 | self.assertTrue(self.key != other_key) |
| 94 | ||
| 95 | def test___ne___name(self): | |
| 96 | other_key = private_key.PrivateKey(self.algorithm, | |
| 97 | self.length, | |
| 98 | self.encoded, | |
| 99 | 'other key') | |
| 100 | self.assertTrue(self.key != other_key) | |
| 15 | 15 | """ |
| 16 | 16 | Test cases for the public key class. |
| 17 | 17 | """ |
| 18 | ||
| 19 | 18 | from castellan.common.objects import public_key |
| 20 | 19 | from castellan.tests import base |
| 21 | 20 | from castellan.tests import utils |
| 25 | 24 | |
| 26 | 25 | def _create_key(self): |
| 27 | 26 | return public_key.PublicKey(self.algorithm, |
| 28 | self.length, | |
| 27 | self.bit_length, | |
| 29 | 28 | self.encoded, |
| 30 | self.name) | |
| 29 | self.name, | |
| 30 | self.created) | |
| 31 | 31 | |
| 32 | 32 | def setUp(self): |
| 33 | 33 | self.algorithm = 'RSA' |
| 34 | self.length = 2048 | |
| 34 | self.bit_length = 2048 | |
| 35 | 35 | self.encoded = bytes(utils.get_public_key_der()) |
| 36 | 36 | self.name = 'my key' |
| 37 | self.created = 1448088699 | |
| 37 | 38 | |
| 38 | 39 | super(PublicKeyTestCase, self).setUp() |
| 39 | 40 | |
| 40 | 41 | def test_get_algorithm(self): |
| 41 | 42 | self.assertEqual(self.algorithm, self.key.algorithm) |
| 42 | 43 | |
| 43 | def test_get_length(self): | |
| 44 | self.assertEqual(self.length, self.key.bit_length) | |
| 44 | def test_get_bit_length(self): | |
| 45 | self.assertEqual(self.bit_length, self.key.bit_length) | |
| 45 | 46 | |
| 46 | 47 | def test_get_name(self): |
| 47 | 48 | self.assertEqual(self.name, self.key.name) |
| 52 | 53 | def test_get_encoded(self): |
| 53 | 54 | self.assertEqual(self.encoded, self.key.get_encoded()) |
| 54 | 55 | |
| 56 | def test_get_created(self): | |
| 57 | self.assertEqual(self.created, self.key.created) | |
| 58 | ||
| 59 | def test_get_created_none(self): | |
| 60 | created = None | |
| 61 | key = public_key.PublicKey(self.algorithm, | |
| 62 | self.bit_length, | |
| 63 | self.encoded, | |
| 64 | self.name, | |
| 65 | created) | |
| 66 | ||
| 67 | self.assertEqual(created, key.created) | |
| 68 | ||
| 55 | 69 | def test___eq__(self): |
| 56 | 70 | self.assertTrue(self.key == self.key) |
| 57 | 71 | self.assertTrue(self.key is self.key) |
| 60 | 74 | self.assertFalse(None == self.key) |
| 61 | 75 | |
| 62 | 76 | other_key = public_key.PublicKey(self.algorithm, |
| 63 | self.length, | |
| 64 | self.encoded, | |
| 65 | self.name) | |
| 77 | self.bit_length, | |
| 78 | self.encoded) | |
| 66 | 79 | self.assertTrue(self.key == other_key) |
| 67 | 80 | self.assertFalse(self.key is other_key) |
| 68 | 81 | |
| 72 | 85 | |
| 73 | 86 | def test___ne___algorithm(self): |
| 74 | 87 | other_key = public_key.PublicKey('DSA', |
| 75 | self.length, | |
| 88 | self.bit_length, | |
| 76 | 89 | self.encoded, |
| 77 | 90 | self.name) |
| 78 | 91 | self.assertTrue(self.key != other_key) |
| 79 | 92 | |
| 80 | def test___ne___length(self): | |
| 93 | def test___ne___bit_length(self): | |
| 81 | 94 | other_key = public_key.PublicKey(self.algorithm, |
| 82 | 95 | 4096, |
| 83 | 96 | self.encoded, |
| 87 | 100 | def test___ne___encoded(self): |
| 88 | 101 | different_encoded = bytes(utils.get_public_key_der()) + b'\x00' |
| 89 | 102 | other_key = public_key.PublicKey(self.algorithm, |
| 90 | self.length, | |
| 103 | self.bit_length, | |
| 91 | 104 | different_encoded, |
| 92 | 105 | self.name) |
| 93 | 106 | self.assertTrue(self.key != other_key) |
| 94 | ||
| 95 | def test___ne__name(self): | |
| 96 | other_key = public_key.PublicKey(self.algorithm, | |
| 97 | self.length, | |
| 98 | self.encoded, | |
| 99 | 'other key') | |
| 100 | self.assertTrue(self.key != other_key) | |
| 15 | 15 | """ |
| 16 | 16 | Test cases for the symmetric key class. |
| 17 | 17 | """ |
| 18 | ||
| 19 | 18 | from castellan.common.objects import symmetric_key as sym_key |
| 20 | 19 | from castellan.tests import base |
| 21 | 20 | |
| 26 | 25 | return sym_key.SymmetricKey(self.algorithm, |
| 27 | 26 | self.bit_length, |
| 28 | 27 | self.encoded, |
| 29 | self.name) | |
| 28 | self.name, | |
| 29 | self.created) | |
| 30 | 30 | |
| 31 | 31 | def setUp(self): |
| 32 | 32 | self.algorithm = 'AES' |
| 33 | 33 | self.encoded = bytes(b'0' * 64) |
| 34 | 34 | self.bit_length = len(self.encoded) * 8 |
| 35 | 35 | self.name = 'my key' |
| 36 | self.created = 1448088699 | |
| 36 | 37 | |
| 37 | 38 | super(SymmetricKeyTestCase, self).setUp() |
| 38 | 39 | |
| 51 | 52 | def test_get_bit_length(self): |
| 52 | 53 | self.assertEqual(self.bit_length, self.key.bit_length) |
| 53 | 54 | |
| 55 | def test_get_created(self): | |
| 56 | self.assertEqual(self.created, self.key.created) | |
| 57 | ||
| 58 | def test_get_created_none(self): | |
| 59 | created = None | |
| 60 | key = sym_key.SymmetricKey(self.algorithm, | |
| 61 | self.bit_length, | |
| 62 | self.encoded, | |
| 63 | self.name, | |
| 64 | created) | |
| 65 | ||
| 66 | self.assertEqual(created, key.created) | |
| 67 | ||
| 54 | 68 | def test___eq__(self): |
| 55 | 69 | self.assertTrue(self.key == self.key) |
| 56 | 70 | self.assertTrue(self.key is self.key) |
| 60 | 74 | |
| 61 | 75 | other_key = sym_key.SymmetricKey(self.algorithm, |
| 62 | 76 | self.bit_length, |
| 63 | self.encoded, | |
| 64 | self.name) | |
| 77 | self.encoded) | |
| 65 | 78 | self.assertTrue(self.key == other_key) |
| 66 | 79 | self.assertFalse(self.key is other_key) |
| 67 | 80 | |
| 76 | 89 | self.name) |
| 77 | 90 | self.assertTrue(self.key != other_key) |
| 78 | 91 | |
| 79 | def test___ne___length(self): | |
| 92 | def test___ne___bit_length(self): | |
| 80 | 93 | other_key = sym_key.SymmetricKey(self.algorithm, |
| 81 | 94 | self.bit_length * 2, |
| 82 | 95 | self.encoded, |
| 90 | 103 | different_encoded, |
| 91 | 104 | self.name) |
| 92 | 105 | self.assertTrue(self.key != other_key) |
| 93 | ||
| 94 | def test___ne___name(self): | |
| 95 | other_key = sym_key.SymmetricKey(self.algorithm, | |
| 96 | self.bit_length, | |
| 97 | self.encoded, | |
| 98 | 'other key') | |
| 99 | self.assertTrue(self.key != other_key) | |
| 15 | 15 | """ |
| 16 | 16 | Test cases for the X.509 certificate class. |
| 17 | 17 | """ |
| 18 | ||
| 19 | 18 | from castellan.common.objects import x_509 |
| 20 | 19 | from castellan.tests import base |
| 21 | 20 | from castellan.tests import utils |
| 24 | 23 | class X509TestCase(base.CertificateTestCase): |
| 25 | 24 | |
| 26 | 25 | def _create_cert(self): |
| 27 | return x_509.X509(self.data, self.name) | |
| 26 | return x_509.X509(self.data, | |
| 27 | self.name, | |
| 28 | self.created) | |
| 28 | 29 | |
| 29 | 30 | def setUp(self): |
| 30 | 31 | self.data = utils.get_certificate_der() |
| 31 | 32 | self.name = 'my cert' |
| 33 | self.created = 1448088699 | |
| 32 | 34 | |
| 33 | 35 | super(X509TestCase, self).setUp() |
| 34 | 36 | |
| 41 | 43 | def test_get_encoded(self): |
| 42 | 44 | self.assertEqual(self.data, self.cert.get_encoded()) |
| 43 | 45 | |
| 46 | def test_get_created(self): | |
| 47 | self.assertEqual(self.created, self.cert.created) | |
| 48 | ||
| 49 | def test_get_created_none(self): | |
| 50 | created = None | |
| 51 | cert = x_509.X509(self.data, | |
| 52 | self.name, | |
| 53 | created) | |
| 54 | ||
| 55 | self.assertEqual(created, cert.created) | |
| 56 | ||
| 44 | 57 | def test___eq__(self): |
| 45 | 58 | self.assertTrue(self.cert == self.cert) |
| 46 | 59 | self.assertTrue(self.cert is self.cert) |
| 48 | 61 | self.assertFalse(self.cert is None) |
| 49 | 62 | self.assertFalse(None == self.cert) |
| 50 | 63 | |
| 51 | other_x_509 = x_509.X509(self.data, self.name) | |
| 64 | other_x_509 = x_509.X509(self.data) | |
| 52 | 65 | self.assertTrue(self.cert == other_x_509) |
| 53 | 66 | self.assertFalse(self.cert is other_x_509) |
| 54 | 67 | |
| 59 | 72 | def test___ne___data(self): |
| 60 | 73 | other_x509 = x_509.X509(b'\x00\x00\x00', self.name) |
| 61 | 74 | self.assertTrue(self.cert != other_x509) |
| 62 | ||
| 63 | def test___ne__name(self): | |
| 64 | other_x509 = x_509.X509(self.data, "other x509") | |
| 65 | self.assertTrue(self.cert != other_x509) | |