mirror of https://github.com/OpenKMIP/PyKMIP.git
665 lines
32 KiB
Python
665 lines
32 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 testtools
|
|
|
|
from kmip.core import attributes
|
|
from kmip.core import enums
|
|
from kmip.core import misc
|
|
from kmip.core import secrets
|
|
from kmip.core import objects as cobjects
|
|
|
|
from kmip.pie import factory
|
|
from kmip.pie import objects as pobjects
|
|
|
|
|
|
class TestObjectFactory(testtools.TestCase):
|
|
"""
|
|
Test suite for the ObjectFactory.
|
|
"""
|
|
|
|
def setUp(self):
|
|
super(TestObjectFactory, self).setUp()
|
|
self.factory = factory.ObjectFactory()
|
|
|
|
# Key encoding obtained from Sections 3.1.5, 13.2, 13.4, and 14.2 of
|
|
# the KMIP 1.1 test documentation.
|
|
self.symmetric_bytes = (
|
|
b'\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E'
|
|
b'\x0F')
|
|
self.public_bytes = (
|
|
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')
|
|
self.private_bytes = (
|
|
b'\x30\x82\x04\xA5\x02\x01\x00\x02\x82\x01\x01\x00\xAB\x7F\x16\x1C'
|
|
b'\x00\x42\x49\x6C\xCD\x6C\x6D\x4D\xAD\xB9\x19\x97\x34\x35\x35\x77'
|
|
b'\x76\x00\x3A\xCF\x54\xB7\xAF\x1E\x44\x0A\xFB\x80\xB6\x4A\x87\x55'
|
|
b'\xF8\x00\x2C\xFE\xBA\x6B\x18\x45\x40\xA2\xD6\x60\x86\xD7\x46\x48'
|
|
b'\x34\x6D\x75\xB8\xD7\x18\x12\xB2\x05\x38\x7C\x0F\x65\x83\xBC\x4D'
|
|
b'\x7D\xC7\xEC\x11\x4F\x3B\x17\x6B\x79\x57\xC4\x22\xE7\xD0\x3F\xC6'
|
|
b'\x26\x7F\xA2\xA6\xF8\x9B\x9B\xEE\x9E\x60\xA1\xD7\xC2\xD8\x33\xE5'
|
|
b'\xA5\xF4\xBB\x0B\x14\x34\xF4\xE7\x95\xA4\x11\x00\xF8\xAA\x21\x49'
|
|
b'\x00\xDF\x8B\x65\x08\x9F\x98\x13\x5B\x1C\x67\xB7\x01\x67\x5A\xBD'
|
|
b'\xBC\x7D\x57\x21\xAA\xC9\xD1\x4A\x7F\x08\x1F\xCE\xC8\x0B\x64\xE8'
|
|
b'\xA0\xEC\xC8\x29\x53\x53\xC7\x95\x32\x8A\xBF\x70\xE1\xB4\x2E\x7B'
|
|
b'\xB8\xB7\xF4\xE8\xAC\x8C\x81\x0C\xDB\x66\xE3\xD2\x11\x26\xEB\xA8'
|
|
b'\xDA\x7D\x0C\xA3\x41\x42\xCB\x76\xF9\x1F\x01\x3D\xA8\x09\xE9\xC1'
|
|
b'\xB7\xAE\x64\xC5\x41\x30\xFB\xC2\x1D\x80\xE9\xC2\xCB\x06\xC5\xC8'
|
|
b'\xD7\xCC\xE8\x94\x6A\x9A\xC9\x9B\x1C\x28\x15\xC3\x61\x2A\x29\xA8'
|
|
b'\x2D\x73\xA1\xF9\x93\x74\xFE\x30\xE5\x49\x51\x66\x2A\x6E\xDA\x29'
|
|
b'\xC6\xFC\x41\x13\x35\xD5\xDC\x74\x26\xB0\xF6\x05\x02\x03\x01\x00'
|
|
b'\x01\x02\x82\x01\x00\x3B\x12\x45\x5D\x53\xC1\x81\x65\x16\xC5\x18'
|
|
b'\x49\x3F\x63\x98\xAA\xFA\x72\xB1\x7D\xFA\x89\x4D\xB8\x88\xA7\xD4'
|
|
b'\x8C\x0A\x47\xF6\x25\x79\xA4\xE6\x44\xF8\x6D\xA7\x11\xFE\xC8\x50'
|
|
b'\xCD\xD9\xDB\xBD\x17\xF6\x9A\x44\x3D\x2E\xC1\xDD\x60\xD3\xC6\x18'
|
|
b'\xFA\x74\xCD\xE5\xFD\xAF\xAB\xD6\xBA\xA2\x6E\xB0\xA3\xAD\xB4\xDE'
|
|
b'\xF6\x48\x0F\xB1\x21\x8C\xD3\xB0\x83\xE2\x52\xE8\x85\xB6\xF0\x72'
|
|
b'\x9F\x98\xB2\x14\x4D\x2B\x72\x29\x3E\x1B\x11\xD7\x33\x93\xBC\x41'
|
|
b'\xF7\x5B\x15\xEE\x3D\x75\x69\xB4\x99\x5E\xD1\xA1\x44\x25\xDA\x43'
|
|
b'\x19\xB7\xB2\x6B\x0E\x8F\xEF\x17\xC3\x75\x42\xAE\x5C\x6D\x58\x49'
|
|
b'\xF8\x72\x09\x56\x7F\x39\x25\xA4\x7B\x01\x6D\x56\x48\x59\x71\x7B'
|
|
b'\xC5\x7F\xCB\x45\x22\xD0\xAA\x49\xCE\x81\x6E\x5B\xE7\xB3\x08\x81'
|
|
b'\x93\x23\x6E\xC9\xEF\xFF\x14\x08\x58\x04\x5B\x73\xC5\xD7\x9B\xAF'
|
|
b'\x38\xF7\xC6\x7F\x04\xC5\xDC\xF0\xE3\x80\x6A\xD9\x82\xD1\x25\x90'
|
|
b'\x58\xC3\x47\x3E\x84\x71\x79\xA8\x78\xF2\xC6\xB3\xBD\x96\x8F\xB9'
|
|
b'\x9E\xA4\x6E\x91\x85\x89\x2F\x36\x76\xE7\x89\x65\xC2\xAE\xD4\x87'
|
|
b'\x7B\xA3\x91\x7D\xF0\x7C\x5E\x92\x74\x74\xF1\x9E\x76\x4B\xA6\x1D'
|
|
b'\xC3\x8D\x63\xBF\x29\x02\x81\x81\x00\xD5\xC6\x9C\x8C\x3C\xDC\x24'
|
|
b'\x64\x74\x4A\x79\x37\x13\xDA\xFB\x9F\x1D\xBC\x79\x9F\xF9\x64\x23'
|
|
b'\xFE\xCD\x3C\xBA\x79\x42\x86\xBC\xE9\x20\xF4\xB5\xC1\x83\xF9\x9E'
|
|
b'\xE9\x02\x8D\xB6\x21\x2C\x62\x77\xC4\xC8\x29\x7F\xCF\xBC\xE7\xF7'
|
|
b'\xC2\x4C\xA4\xC5\x1F\xC7\x18\x2F\xB8\xF4\x01\x9F\xB1\xD5\x65\x96'
|
|
b'\x74\xC5\xCB\xE6\xD5\xFA\x99\x20\x51\x34\x17\x60\xCD\x00\x73\x57'
|
|
b'\x29\xA0\x70\xA9\xE5\x4D\x34\x2B\xEB\xA8\xEF\x47\xEE\x82\xD3\xA0'
|
|
b'\x1B\x04\xCE\xC4\xA0\x0D\x4D\xDB\x41\xE3\x51\x16\xFC\x22\x1E\x85'
|
|
b'\x4B\x43\xA6\x96\xC0\xE6\x41\x9B\x1B\x02\x81\x81\x00\xCD\x5E\xA7'
|
|
b'\x70\x27\x89\x06\x4B\x67\x35\x40\xCB\xFF\x09\x35\x6A\xD8\x0B\xC3'
|
|
b'\xD5\x92\x81\x2E\xBA\x47\x61\x0B\x9F\xAC\x6A\xEC\xEF\xE2\x2A\xCA'
|
|
b'\xE4\x38\x45\x9C\xDA\x74\xE5\x96\x53\xD8\x8C\x04\x18\x9D\x34\x39'
|
|
b'\x9B\xF5\xB1\x4B\x92\x0E\x34\xEF\x38\xA7\xD0\x9F\xE6\x95\x93\x39'
|
|
b'\x6E\x8F\xE7\x35\xE6\xF0\xA6\xAE\x49\x90\x40\x10\x41\xD8\xA4\x06'
|
|
b'\xB6\xFD\x86\xA1\x16\x1E\x45\xF9\x5A\x3E\xAA\x5C\x10\x12\xE6\x66'
|
|
b'\x2E\x44\xF1\x5F\x33\x5A\xC9\x71\xE1\x76\x6B\x2B\xB9\xC9\x85\x10'
|
|
b'\x99\x74\x14\x1B\x44\xD3\x7E\x1E\x31\x98\x20\xA5\x5F\x02\x81\x81'
|
|
b'\x00\xB2\x87\x12\x37\xBF\x9F\xAD\x38\xC3\x31\x6A\xB7\x87\x7A\x6A'
|
|
b'\x86\x80\x63\xE5\x42\xA7\x18\x6D\x43\x1E\x8D\x27\xC1\x9A\xC0\x41'
|
|
b'\x45\x84\x03\x39\x42\xE9\xFF\x6E\x29\x73\xBB\x7B\x2D\x8B\x0E\x94'
|
|
b'\xAD\x1E\xE8\x21\x58\x10\x8F\xBC\x86\x64\x51\x7A\x5A\x46\x7F\xB9'
|
|
b'\x63\x01\x4B\xD5\xDC\xC2\xB4\xFB\x08\x7C\x23\x03\x9D\x11\x92\x0D'
|
|
b'\xBE\x22\xFD\x9F\x16\xB4\xD8\x9E\x23\x22\x5C\xD4\x55\xAD\xBA\xF3'
|
|
b'\x2E\xF4\x3F\x18\x58\x64\xA3\x6D\x63\x03\x09\xD6\x85\x3F\x77\x14'
|
|
b'\xB3\x9A\xAE\x1E\xBE\xE3\x93\x8F\x87\xC2\x70\x7E\x17\x8C\x73\x9F'
|
|
b'\x9F\x02\x81\x81\x00\x96\x90\xBE\xD1\x4B\x2A\xFA\xA2\x6D\x98\x6D'
|
|
b'\x59\x22\x31\xEE\x27\xD7\x1D\x49\x06\x5B\xD2\xBA\x1F\x78\x15\x7E'
|
|
b'\x20\x22\x98\x81\xFD\x9D\x23\x22\x7D\x0F\x84\x79\xEA\xEF\xA9\x22'
|
|
b'\xFD\x75\xD5\xB1\x6B\x1A\x56\x1F\xA6\x68\x0B\x04\x0C\xA0\xBD\xCE'
|
|
b'\x65\x0B\x23\xB9\x17\xA4\xB1\xBB\x79\x83\xA7\x4F\xAD\x70\xE1\xC3'
|
|
b'\x05\xCB\xEC\x2B\xFF\x1A\x85\xA7\x26\xA1\xD9\x02\x60\xE4\xF1\x08'
|
|
b'\x4F\x51\x82\x34\xDC\xD3\xFE\x77\x0B\x95\x20\x21\x5B\xD5\x43\xBB'
|
|
b'\x6A\x41\x17\x71\x87\x54\x67\x6A\x34\x17\x16\x66\xA7\x9F\x26\xE7'
|
|
b'\x9C\x14\x9C\x5A\xA1\x02\x81\x81\x00\xA0\xC9\x85\xA0\xA0\xA7\x91'
|
|
b'\xA6\x59\xF9\x97\x31\x13\x4C\x44\xF3\x7B\x2E\x52\x0A\x2C\xEA\x35'
|
|
b'\x80\x0A\xD2\x72\x41\xED\x36\x0D\xFD\xE6\xE8\xCA\x61\x4F\x12\x04'
|
|
b'\x7F\xD0\x8B\x76\xAC\x4D\x13\xC0\x56\xA0\x69\x9E\x2F\x98\xA1\xCA'
|
|
b'\xC9\x10\x11\x29\x4D\x71\x20\x8F\x4A\xBA\xB3\x3B\xA8\x7A\xA0\x51'
|
|
b'\x7F\x41\x5B\xAC\xA8\x8D\x6B\xAC\x00\x60\x88\xFA\x60\x1D\x34\x94'
|
|
b'\x17\xE1\xF0\xC9\xB2\x3A\xFF\xA4\xD4\x96\x61\x8D\xBC\x02\x49\x86'
|
|
b'\xED\x69\x0B\xBB\x7B\x02\x57\x68\xFF\x9D\xF8\xAC\x15\x41\x6F\x48'
|
|
b'\x9F\x81\x29\xC3\x23\x41\xA8\xB4\x4F')
|
|
self.certificate_bytes = (
|
|
b'\x30\x82\x03\x12\x30\x82\x01\xFA\xA0\x03\x02\x01\x02\x02\x01\x01'
|
|
b'\x30\x0D\x06\x09\x2A\x86\x48\x86\xF7\x0D\x01\x01\x05\x05\x00\x30'
|
|
b'\x3B\x31\x0B\x30\x09\x06\x03\x55\x04\x06\x13\x02\x55\x53\x31\x0D'
|
|
b'\x30\x0B\x06\x03\x55\x04\x0A\x13\x04\x54\x45\x53\x54\x31\x0E\x30'
|
|
b'\x0C\x06\x03\x55\x04\x0B\x13\x05\x4F\x41\x53\x49\x53\x31\x0D\x30'
|
|
b'\x0B\x06\x03\x55\x04\x03\x13\x04\x4B\x4D\x49\x50\x30\x1E\x17\x0D'
|
|
b'\x31\x30\x31\x31\x30\x31\x32\x33\x35\x39\x35\x39\x5A\x17\x0D\x32'
|
|
b'\x30\x31\x31\x30\x31\x32\x33\x35\x39\x35\x39\x5A\x30\x3B\x31\x0B'
|
|
b'\x30\x09\x06\x03\x55\x04\x06\x13\x02\x55\x53\x31\x0D\x30\x0B\x06'
|
|
b'\x03\x55\x04\x0A\x13\x04\x54\x45\x53\x54\x31\x0E\x30\x0C\x06\x03'
|
|
b'\x55\x04\x0B\x13\x05\x4F\x41\x53\x49\x53\x31\x0D\x30\x0B\x06\x03'
|
|
b'\x55\x04\x03\x13\x04\x4B\x4D\x49\x50\x30\x82\x01\x22\x30\x0D\x06'
|
|
b'\x09\x2A\x86\x48\x86\xF7\x0D\x01\x01\x01\x05\x00\x03\x82\x01\x0F'
|
|
b'\x00\x30\x82\x01\x0A\x02\x82\x01\x01\x00\xAB\x7F\x16\x1C\x00\x42'
|
|
b'\x49\x6C\xCD\x6C\x6D\x4D\xAD\xB9\x19\x97\x34\x35\x35\x77\x76\x00'
|
|
b'\x3A\xCF\x54\xB7\xAF\x1E\x44\x0A\xFB\x80\xB6\x4A\x87\x55\xF8\x00'
|
|
b'\x2C\xFE\xBA\x6B\x18\x45\x40\xA2\xD6\x60\x86\xD7\x46\x48\x34\x6D'
|
|
b'\x75\xB8\xD7\x18\x12\xB2\x05\x38\x7C\x0F\x65\x83\xBC\x4D\x7D\xC7'
|
|
b'\xEC\x11\x4F\x3B\x17\x6B\x79\x57\xC4\x22\xE7\xD0\x3F\xC6\x26\x7F'
|
|
b'\xA2\xA6\xF8\x9B\x9B\xEE\x9E\x60\xA1\xD7\xC2\xD8\x33\xE5\xA5\xF4'
|
|
b'\xBB\x0B\x14\x34\xF4\xE7\x95\xA4\x11\x00\xF8\xAA\x21\x49\x00\xDF'
|
|
b'\x8B\x65\x08\x9F\x98\x13\x5B\x1C\x67\xB7\x01\x67\x5A\xBD\xBC\x7D'
|
|
b'\x57\x21\xAA\xC9\xD1\x4A\x7F\x08\x1F\xCE\xC8\x0B\x64\xE8\xA0\xEC'
|
|
b'\xC8\x29\x53\x53\xC7\x95\x32\x8A\xBF\x70\xE1\xB4\x2E\x7B\xB8\xB7'
|
|
b'\xF4\xE8\xAC\x8C\x81\x0C\xDB\x66\xE3\xD2\x11\x26\xEB\xA8\xDA\x7D'
|
|
b'\x0C\xA3\x41\x42\xCB\x76\xF9\x1F\x01\x3D\xA8\x09\xE9\xC1\xB7\xAE'
|
|
b'\x64\xC5\x41\x30\xFB\xC2\x1D\x80\xE9\xC2\xCB\x06\xC5\xC8\xD7\xCC'
|
|
b'\xE8\x94\x6A\x9A\xC9\x9B\x1C\x28\x15\xC3\x61\x2A\x29\xA8\x2D\x73'
|
|
b'\xA1\xF9\x93\x74\xFE\x30\xE5\x49\x51\x66\x2A\x6E\xDA\x29\xC6\xFC'
|
|
b'\x41\x13\x35\xD5\xDC\x74\x26\xB0\xF6\x05\x02\x03\x01\x00\x01\xA3'
|
|
b'\x21\x30\x1F\x30\x1D\x06\x03\x55\x1D\x0E\x04\x16\x04\x14\x04\xE5'
|
|
b'\x7B\xD2\xC4\x31\xB2\xE8\x16\xE1\x80\xA1\x98\x23\xFA\xC8\x58\x27'
|
|
b'\x3F\x6B\x30\x0D\x06\x09\x2A\x86\x48\x86\xF7\x0D\x01\x01\x05\x05'
|
|
b'\x00\x03\x82\x01\x01\x00\xA8\x76\xAD\xBC\x6C\x8E\x0F\xF0\x17\x21'
|
|
b'\x6E\x19\x5F\xEA\x76\xBF\xF6\x1A\x56\x7C\x9A\x13\xDC\x50\xD1\x3F'
|
|
b'\xEC\x12\xA4\x27\x3C\x44\x15\x47\xCF\xAB\xCB\x5D\x61\xD9\x91\xE9'
|
|
b'\x66\x31\x9D\xF7\x2C\x0D\x41\xBA\x82\x6A\x45\x11\x2F\xF2\x60\x89'
|
|
b'\xA2\x34\x4F\x4D\x71\xCF\x7C\x92\x1B\x4B\xDF\xAE\xF1\x60\x0D\x1B'
|
|
b'\xAA\xA1\x53\x36\x05\x7E\x01\x4B\x8B\x49\x6D\x4F\xAE\x9E\x8A\x6C'
|
|
b'\x1D\xA9\xAE\xB6\xCB\xC9\x60\xCB\xF2\xFA\xE7\x7F\x58\x7E\xC4\xBB'
|
|
b'\x28\x20\x45\x33\x88\x45\xB8\x8D\xD9\xAE\xEA\x53\xE4\x82\xA3\x6E'
|
|
b'\x73\x4E\x4F\x5F\x03\xB9\xD0\xDF\xC4\xCA\xFC\x6B\xB3\x4E\xA9\x05'
|
|
b'\x3E\x52\xBD\x60\x9E\xE0\x1E\x86\xD9\xB0\x9F\xB5\x11\x20\xC1\x98'
|
|
b'\x34\xA9\x97\xB0\x9C\xE0\x8D\x79\xE8\x13\x11\x76\x2F\x97\x4B\xB1'
|
|
b'\xC8\xC0\x91\x86\xC4\xD7\x89\x33\xE0\xDB\x38\xE9\x05\x08\x48\x77'
|
|
b'\xE1\x47\xC7\x8A\xF5\x2F\xAE\x07\x19\x2F\xF1\x66\xD1\x9F\xA9\x4A'
|
|
b'\x11\xCC\x11\xB2\x7E\xD0\x50\xF7\xA2\x7F\xAE\x13\xB2\x05\xA5\x74'
|
|
b'\xC4\xEE\x00\xAA\x8B\xD6\x5D\x0D\x70\x57\xC9\x85\xC8\x39\xEF\x33'
|
|
b'\x6A\x44\x1E\xD5\x3A\x53\xC6\xB6\xB6\x96\xF1\xBD\xEB\x5F\x7E\xA8'
|
|
b'\x11\xEB\xB2\x5A\x7F\x86')
|
|
self.secret_bytes = (
|
|
b'\x53\x65\x63\x72\x65\x74\x50\x61\x73\x73\x77\x6F\x72\x64')
|
|
self.opaque_bytes = (
|
|
b'\x53\x65\x63\x72\x65\x74\x50\x61\x73\x73\x77\x6F\x72\x64')
|
|
|
|
def tearDown(self):
|
|
super(TestObjectFactory, self).tearDown()
|
|
|
|
def test_init(self):
|
|
"""
|
|
Test that an ObjectFactory can be constructed.
|
|
"""
|
|
factory.ObjectFactory()
|
|
|
|
def test_convert_on_invalid(self):
|
|
"""
|
|
Test that a TypeError is raised when an invalid object is given to the
|
|
convert method.
|
|
"""
|
|
f = factory.ObjectFactory()
|
|
self.assertRaises(TypeError, f.convert, 'invalid')
|
|
|
|
def test_convert_symmetric_key_pie_to_core(self):
|
|
"""
|
|
Test that a Pie symmetric key can be converted into a core symmetric
|
|
key.
|
|
"""
|
|
pie_key = pobjects.SymmetricKey(
|
|
enums.CryptographicAlgorithm.AES, 128, self.symmetric_bytes)
|
|
|
|
core_key = self.factory.convert(pie_key)
|
|
self.assertIsInstance(core_key, secrets.SymmetricKey)
|
|
self._test_core_key(
|
|
core_key, enums.CryptographicAlgorithm.AES, 128,
|
|
self.symmetric_bytes, enums.KeyFormatType.RAW)
|
|
|
|
def test_convert_symmetric_key_core_to_pie(self):
|
|
"""
|
|
Test that a core symmetric key can be converted into a Pie symmetric
|
|
key.
|
|
"""
|
|
format_type = misc.KeyFormatType(enums.KeyFormatType.RAW)
|
|
algorithm = attributes.CryptographicAlgorithm(
|
|
enums.CryptographicAlgorithm.AES)
|
|
length = attributes.CryptographicLength(128)
|
|
key_material = cobjects.KeyMaterial(self.symmetric_bytes)
|
|
key_value = cobjects.KeyValue(key_material)
|
|
key_block = cobjects.KeyBlock(
|
|
key_format_type=format_type,
|
|
key_compression_type=None,
|
|
key_value=key_value,
|
|
cryptographic_algorithm=algorithm,
|
|
cryptographic_length=length,
|
|
key_wrapping_data=None)
|
|
core_key = secrets.SymmetricKey(key_block)
|
|
|
|
pie_key = self.factory.convert(core_key)
|
|
self.assertIsInstance(pie_key, pobjects.SymmetricKey)
|
|
self._test_pie_key(
|
|
pie_key, algorithm.value, length.value, self.symmetric_bytes,
|
|
format_type.value)
|
|
|
|
def test_convert_public_key_pie_to_core(self):
|
|
"""
|
|
Test that a Pie public key can be converted into a core public key.
|
|
"""
|
|
pie_key = pobjects.PublicKey(
|
|
enums.CryptographicAlgorithm.RSA, 2048, self.public_bytes,
|
|
enums.KeyFormatType.PKCS_1)
|
|
|
|
core_key = self.factory.convert(pie_key)
|
|
self.assertIsInstance(core_key, secrets.PublicKey)
|
|
self._test_core_key(
|
|
core_key, enums.CryptographicAlgorithm.RSA, 2048,
|
|
self.public_bytes, enums.KeyFormatType.PKCS_1)
|
|
|
|
def test_convert_public_key_core_to_pie(self):
|
|
"""
|
|
Test that a core public key can be converted into a Pie public key.
|
|
"""
|
|
format_type = misc.KeyFormatType(enums.KeyFormatType.PKCS_1)
|
|
algorithm = attributes.CryptographicAlgorithm(
|
|
enums.CryptographicAlgorithm.RSA)
|
|
length = attributes.CryptographicLength(2048)
|
|
key_material = cobjects.KeyMaterial(self.public_bytes)
|
|
key_value = cobjects.KeyValue(key_material)
|
|
key_block = cobjects.KeyBlock(
|
|
key_format_type=format_type,
|
|
key_compression_type=None,
|
|
key_value=key_value,
|
|
cryptographic_algorithm=algorithm,
|
|
cryptographic_length=length,
|
|
key_wrapping_data=None)
|
|
core_key = secrets.PublicKey(key_block)
|
|
|
|
pie_key = self.factory.convert(core_key)
|
|
self.assertIsInstance(pie_key, pobjects.PublicKey)
|
|
self._test_pie_key(
|
|
pie_key, algorithm.value, length.value, self.public_bytes,
|
|
format_type.value)
|
|
|
|
def test_convert_private_key_pie_to_core(self):
|
|
"""
|
|
Test that a Pie private key can be converted into a core private key.
|
|
"""
|
|
pie_key = pobjects.PrivateKey(
|
|
enums.CryptographicAlgorithm.RSA, 2048, self.private_bytes,
|
|
enums.KeyFormatType.PKCS_8)
|
|
|
|
core_key = self.factory.convert(pie_key)
|
|
self.assertIsInstance(core_key, secrets.PrivateKey)
|
|
self._test_core_key(
|
|
core_key, enums.CryptographicAlgorithm.RSA, 2048,
|
|
self.private_bytes, enums.KeyFormatType.PKCS_8)
|
|
|
|
def test_convert_private_key_core_to_pie(self):
|
|
"""
|
|
Test that a core private key can be converted into a Pie private key.
|
|
"""
|
|
format_type = misc.KeyFormatType(enums.KeyFormatType.PKCS_8)
|
|
algorithm = attributes.CryptographicAlgorithm(
|
|
enums.CryptographicAlgorithm.RSA)
|
|
length = attributes.CryptographicLength(2048)
|
|
key_material = cobjects.KeyMaterial(self.private_bytes)
|
|
key_value = cobjects.KeyValue(key_material)
|
|
key_block = cobjects.KeyBlock(
|
|
key_format_type=format_type,
|
|
key_compression_type=None,
|
|
key_value=key_value,
|
|
cryptographic_algorithm=algorithm,
|
|
cryptographic_length=length,
|
|
key_wrapping_data=None)
|
|
core_key = secrets.PrivateKey(key_block)
|
|
|
|
pie_key = self.factory.convert(core_key)
|
|
self.assertIsInstance(pie_key, pobjects.PrivateKey)
|
|
self._test_pie_key(
|
|
pie_key, algorithm.value, length.value, self.private_bytes,
|
|
format_type.value)
|
|
|
|
def test_convert_certificate_pie_to_core(self):
|
|
"""
|
|
Test that a Pie certificate can be converted into a core certificate.
|
|
"""
|
|
pie_cert = pobjects.X509Certificate(self.certificate_bytes)
|
|
core_cert = self.factory.convert(pie_cert)
|
|
|
|
self.assertIsInstance(core_cert, secrets.Certificate)
|
|
self.assertEqual(
|
|
pie_cert.certificate_type, core_cert.certificate_type.value)
|
|
self.assertEqual(pie_cert.value, core_cert.certificate_value.value)
|
|
|
|
def test_convert_certificate_core_to_pie(self):
|
|
"""
|
|
Test that a core certificate can be converted into a Pie certificate.
|
|
"""
|
|
core_cert = secrets.Certificate(
|
|
enums.CertificateType.X_509, self.certificate_bytes)
|
|
pie_cert = self.factory.convert(core_cert)
|
|
|
|
self.assertIsInstance(pie_cert, pobjects.X509Certificate)
|
|
self.assertEqual(
|
|
core_cert.certificate_type.value, pie_cert.certificate_type)
|
|
self.assertEqual(core_cert.certificate_value.value, pie_cert.value)
|
|
|
|
def test_convert_secret_data_pie_to_core(self):
|
|
"""
|
|
Test that a Pie secret data object can be converted into a core secret
|
|
data object.
|
|
"""
|
|
pie_secret = pobjects.SecretData(
|
|
self.secret_bytes, enums.SecretDataType.PASSWORD)
|
|
core_secret = self.factory.convert(pie_secret)
|
|
|
|
self.assertIsInstance(core_secret, secrets.SecretData)
|
|
|
|
data_type = core_secret.secret_data_type.value
|
|
self.assertEqual(enums.SecretDataType.PASSWORD, data_type)
|
|
|
|
key_block = core_secret.key_block
|
|
self.assertIsInstance(key_block, cobjects.KeyBlock)
|
|
|
|
key_value = key_block.key_value
|
|
self.assertIsInstance(key_value, cobjects.KeyValue)
|
|
|
|
key_material = key_value.key_material
|
|
self.assertIsInstance(key_material, cobjects.KeyMaterial)
|
|
self.assertEqual(self.secret_bytes, key_material.value)
|
|
|
|
def test_convert_secret_data_core_to_pie(self):
|
|
"""
|
|
Test that a core secret data object can be converted into a Pie secret
|
|
data object.
|
|
"""
|
|
format_type = misc.KeyFormatType(enums.KeyFormatType.OPAQUE)
|
|
key_material = cobjects.KeyMaterial(self.secret_bytes)
|
|
key_value = cobjects.KeyValue(key_material)
|
|
key_block = cobjects.KeyBlock(
|
|
key_format_type=format_type,
|
|
key_compression_type=None,
|
|
key_value=key_value,
|
|
cryptographic_algorithm=None,
|
|
cryptographic_length=None,
|
|
key_wrapping_data=None)
|
|
data_type = secrets.SecretData.SecretDataType(
|
|
enums.SecretDataType.PASSWORD)
|
|
core_key = secrets.SecretData(data_type, key_block)
|
|
|
|
pie_key = self.factory.convert(core_key)
|
|
self.assertIsInstance(pie_key, pobjects.SecretData)
|
|
self.assertEqual(enums.SecretDataType.PASSWORD, pie_key.data_type)
|
|
self.assertEqual(self.secret_bytes, pie_key.value)
|
|
|
|
def test_convert_opaque_object_pie_to_core(self):
|
|
"""
|
|
Test that a Pie opaque object can be converted into a core opaque
|
|
object.
|
|
"""
|
|
pie_obj = pobjects.OpaqueObject(
|
|
self.opaque_bytes, enums.OpaqueDataType.NONE)
|
|
core_obj = self.factory.convert(pie_obj)
|
|
|
|
self.assertIsInstance(core_obj, secrets.OpaqueObject)
|
|
|
|
opaque_type = core_obj.opaque_data_type.value
|
|
self.assertEqual(enums.OpaqueDataType.NONE, opaque_type)
|
|
|
|
value = core_obj.opaque_data_value.value
|
|
self.assertEqual(self.opaque_bytes, value)
|
|
|
|
def test_convert_opaque_object_core_to_pie(self):
|
|
"""
|
|
Test that a core opaque object can be converted into a Pie opaque
|
|
object.
|
|
"""
|
|
opaque_data_type = secrets.OpaqueObject.OpaqueDataType(
|
|
enums.OpaqueDataType.NONE)
|
|
opaque_data_value = secrets.OpaqueObject.OpaqueDataValue(
|
|
self.opaque_bytes)
|
|
core_obj = secrets.OpaqueObject(opaque_data_type, opaque_data_value)
|
|
pie_obj = self.factory.convert(core_obj)
|
|
|
|
self.assertIsInstance(pie_obj, pobjects.OpaqueObject)
|
|
self.assertEqual(enums.OpaqueDataType.NONE, pie_obj.opaque_type)
|
|
self.assertEqual(self.opaque_bytes, pie_obj.value)
|
|
|
|
def test_build_pie_symmetric_key(self):
|
|
"""
|
|
Test that a core SymmetricKey object can be converted into a Pie
|
|
SymmetricKey object.
|
|
"""
|
|
format_type = misc.KeyFormatType(enums.KeyFormatType.RAW)
|
|
algorithm = attributes.CryptographicAlgorithm(
|
|
enums.CryptographicAlgorithm.AES)
|
|
length = attributes.CryptographicLength(128)
|
|
key_material = cobjects.KeyMaterial(self.symmetric_bytes)
|
|
key_value = cobjects.KeyValue(key_material)
|
|
key_block = cobjects.KeyBlock(
|
|
key_format_type=format_type,
|
|
key_compression_type=None,
|
|
key_value=key_value,
|
|
cryptographic_algorithm=algorithm,
|
|
cryptographic_length=length,
|
|
key_wrapping_data=None)
|
|
core_key = secrets.SymmetricKey(key_block)
|
|
pie_key = self.factory._build_pie_key(core_key, pobjects.SymmetricKey)
|
|
|
|
self.assertIsInstance(pie_key, pobjects.SymmetricKey)
|
|
self._test_pie_key(
|
|
pie_key, algorithm.value, length.value, self.symmetric_bytes,
|
|
format_type.value)
|
|
|
|
def test_build_pie_symmetric_key_on_invalid_format(self):
|
|
"""
|
|
Test that a TypeError exception is raised when attempting to create a
|
|
Pie SymmetricKey object from a core SymmetricKey object with an
|
|
incompatible format.
|
|
"""
|
|
format_type = misc.KeyFormatType(enums.KeyFormatType.OPAQUE)
|
|
algorithm = attributes.CryptographicAlgorithm(
|
|
enums.CryptographicAlgorithm.AES)
|
|
length = attributes.CryptographicLength(128)
|
|
key_material = cobjects.KeyMaterial(self.symmetric_bytes)
|
|
key_value = cobjects.KeyValue(key_material)
|
|
key_block = cobjects.KeyBlock(
|
|
key_format_type=format_type,
|
|
key_compression_type=None,
|
|
key_value=key_value,
|
|
cryptographic_algorithm=algorithm,
|
|
cryptographic_length=length,
|
|
key_wrapping_data=None)
|
|
core_key = secrets.SymmetricKey(key_block)
|
|
|
|
args = [core_key, pobjects.SymmetricKey]
|
|
self.assertRaises(TypeError, self.factory._build_pie_key, *args)
|
|
|
|
def test_build_pie_asymmetric_key(self):
|
|
"""
|
|
Test that a core asymmetric key object can be converted into a Pie
|
|
asymmetric object.
|
|
"""
|
|
format_type = misc.KeyFormatType(enums.KeyFormatType.PKCS_1)
|
|
algorithm = attributes.CryptographicAlgorithm(
|
|
enums.CryptographicAlgorithm.RSA)
|
|
length = attributes.CryptographicLength(2048)
|
|
key_material = cobjects.KeyMaterial(self.public_bytes)
|
|
key_value = cobjects.KeyValue(key_material)
|
|
key_block = cobjects.KeyBlock(
|
|
key_format_type=format_type,
|
|
key_compression_type=None,
|
|
key_value=key_value,
|
|
cryptographic_algorithm=algorithm,
|
|
cryptographic_length=length,
|
|
key_wrapping_data=None)
|
|
core_key = secrets.PublicKey(key_block)
|
|
pie_key = self.factory._build_pie_key(core_key, pobjects.PublicKey)
|
|
|
|
self.assertIsInstance(pie_key, pobjects.PublicKey)
|
|
self._test_pie_key(
|
|
pie_key, algorithm.value, length.value, self.public_bytes,
|
|
format_type.value)
|
|
|
|
def test_build_core_key(self):
|
|
"""
|
|
Test that a Pie key object can be converted into a core key object.
|
|
"""
|
|
pie_key = pobjects.SymmetricKey(
|
|
enums.CryptographicAlgorithm.AES, 128, self.symmetric_bytes)
|
|
core_key = self.factory._build_core_key(pie_key, secrets.SymmetricKey)
|
|
|
|
self.assertIsInstance(core_key, secrets.SymmetricKey)
|
|
self._test_core_key(
|
|
core_key, enums.CryptographicAlgorithm.AES, 128,
|
|
self.symmetric_bytes, enums.KeyFormatType.RAW)
|
|
|
|
def test_build_pie_certificate_on_invalid_type(self):
|
|
"""
|
|
Test that a TypeError exception is raised when attempting to create a
|
|
Pie Certificate object from a core Certificate object with an
|
|
unsupported certificate type.
|
|
"""
|
|
core_cert = secrets.Certificate(
|
|
enums.CertificateType.PGP, self.certificate_bytes)
|
|
args = (core_cert, )
|
|
self.assertRaises(
|
|
TypeError, self.factory._build_pie_certificate, *args)
|
|
|
|
def _test_core_key(self, key, algorithm, length, value, format_type):
|
|
key_block = key.key_block
|
|
self.assertIsInstance(key_block, cobjects.KeyBlock)
|
|
|
|
key_format_type = key_block.key_format_type
|
|
self.assertIsInstance(key_format_type, misc.KeyFormatType)
|
|
self.assertEqual(key_format_type.value, format_type)
|
|
|
|
cryptographic_algorithm = key_block.cryptographic_algorithm
|
|
self.assertIsInstance(
|
|
cryptographic_algorithm, attributes.CryptographicAlgorithm)
|
|
self.assertEqual(
|
|
cryptographic_algorithm.value, algorithm)
|
|
|
|
cryptographic_length = key_block.cryptographic_length
|
|
self.assertIsInstance(
|
|
cryptographic_length, attributes.CryptographicLength)
|
|
self.assertEqual(cryptographic_length.value, length)
|
|
|
|
key_value = key_block.key_value
|
|
self.assertIsInstance(key_value, cobjects.KeyValue)
|
|
|
|
key_material = key_value.key_material
|
|
self.assertIsInstance(key_material, cobjects.KeyMaterial)
|
|
self.assertEqual(key_material.value, value)
|
|
|
|
def _test_pie_key(self, key, algorithm, length, value, format_type):
|
|
self.assertEqual(key.cryptographic_algorithm, algorithm)
|
|
self.assertEqual(key.cryptographic_length, length)
|
|
self.assertEqual(key.key_format_type, format_type)
|
|
self.assertEqual(key.value, value)
|
|
|
|
def test_build_cryptographic_parameters(self):
|
|
cryptographic_parameters = cobjects.CryptographicParameters(
|
|
block_cipher_mode=enums.BlockCipherMode.CBC,
|
|
padding_method=enums.PaddingMethod.ANSI_X923,
|
|
hashing_algorithm=enums.HashingAlgorithm.SHA_256,
|
|
key_role_type=enums.KeyRoleType.KEK,
|
|
digital_signature_algorithm=enums.DigitalSignatureAlgorithm.
|
|
DSA_WITH_SHA1,
|
|
cryptographic_algorithm=enums.CryptographicAlgorithm.AES,
|
|
random_iv=True,
|
|
iv_length=32,
|
|
tag_length=33,
|
|
fixed_field_length=34,
|
|
invocation_field_length=35,
|
|
counter_length=36,
|
|
initial_counter_value=0
|
|
)
|
|
|
|
result = self.factory._build_cryptographic_parameters(
|
|
cryptographic_parameters
|
|
)
|
|
self.assertIsInstance(result, dict)
|
|
self.assertEqual(
|
|
enums.BlockCipherMode.CBC,
|
|
result.get('block_cipher_mode')
|
|
)
|
|
self.assertEqual(
|
|
enums.PaddingMethod.ANSI_X923,
|
|
result.get('padding_method')
|
|
)
|
|
self.assertEqual(
|
|
enums.HashingAlgorithm.SHA_256,
|
|
result.get('hashing_algorithm')
|
|
)
|
|
self.assertEqual(
|
|
enums.KeyRoleType.KEK,
|
|
result.get('key_role_type')
|
|
)
|
|
self.assertEqual(
|
|
enums.DigitalSignatureAlgorithm.DSA_WITH_SHA1,
|
|
result.get('digital_signature_algorithm')
|
|
)
|
|
self.assertEqual(
|
|
enums.CryptographicAlgorithm.AES,
|
|
result.get('cryptographic_algorithm')
|
|
)
|
|
self.assertEqual(True, result.get('random_iv'))
|
|
self.assertEqual(32, result.get('iv_length'))
|
|
self.assertEqual(33, result.get('tag_length'))
|
|
self.assertEqual(34, result.get('fixed_field_length'))
|
|
self.assertEqual(35, result.get('invocation_field_length'))
|
|
self.assertEqual(36, result.get('counter_length'))
|
|
self.assertEqual(0, result.get('initial_counter_value'))
|
|
|
|
def test_build_key_wrapping_data(self):
|
|
key_wrapping_data = cobjects.KeyWrappingData(
|
|
wrapping_method=enums.WrappingMethod.ENCRYPT,
|
|
encryption_key_information=cobjects.EncryptionKeyInformation(
|
|
unique_identifier='1',
|
|
cryptographic_parameters=cobjects.CryptographicParameters(
|
|
block_cipher_mode=enums.BlockCipherMode.CBC
|
|
)
|
|
),
|
|
mac_signature_key_information=cobjects.MACSignatureKeyInformation(
|
|
unique_identifier='2',
|
|
cryptographic_parameters=cobjects.CryptographicParameters(
|
|
block_cipher_mode=enums.BlockCipherMode.CCM
|
|
)
|
|
),
|
|
mac_signature=b'\x01',
|
|
iv_counter_nonce=b'\x02',
|
|
encoding_option=enums.EncodingOption.NO_ENCODING
|
|
)
|
|
|
|
result = self.factory._build_key_wrapping_data(
|
|
key_wrapping_data
|
|
)
|
|
self.assertIsInstance(result, dict)
|
|
self.assertEqual(
|
|
enums.WrappingMethod.ENCRYPT,
|
|
result.get('wrapping_method')
|
|
)
|
|
self.assertIsInstance(result.get('encryption_key_information'), dict)
|
|
eki = result.get('encryption_key_information')
|
|
self.assertEqual('1', eki.get('unique_identifier'))
|
|
self.assertIsInstance(eki.get('cryptographic_parameters'), dict)
|
|
self.assertIsInstance(
|
|
result.get('mac_signature_key_information'),
|
|
dict
|
|
)
|
|
mski = result.get('mac_signature_key_information')
|
|
self.assertEqual('2', mski.get('unique_identifier'))
|
|
self.assertIsInstance(mski.get('cryptographic_parameters'), dict)
|
|
self.assertEqual(b'\x01', result.get('mac_signature'))
|
|
self.assertEqual(b'\x02', result.get('iv_counter_nonce'))
|
|
self.assertEqual(
|
|
enums.EncodingOption.NO_ENCODING,
|
|
result.get('encoding_option')
|
|
)
|