mirror of
https://github.com/OpenKMIP/PyKMIP.git
synced 2025-04-08 19:25:06 +02:00
a8713fc909
This change adds conversion utilities for SplitKey objects, allowing for conversions between the Pie and Core object spaces. The server is also updated to recognize the new Pie SplitKey object. Unit tests have been added and tweaked to accommodate these changes. Partially implements #545
829 lines
38 KiB
Python
829 lines
38 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_convert_split_key_pie_to_core(self):
|
|
"""
|
|
Test that a Pie split key object can be converted into a core split
|
|
key object.
|
|
"""
|
|
pie_split_key = pobjects.SplitKey(
|
|
cryptographic_algorithm=enums.CryptographicAlgorithm.AES,
|
|
cryptographic_length=128,
|
|
key_value=self.symmetric_bytes,
|
|
cryptographic_usage_masks=[enums.CryptographicUsageMask.EXPORT],
|
|
name="Split Key",
|
|
key_format_type=enums.KeyFormatType.RAW,
|
|
key_wrapping_data=None,
|
|
split_key_parts=3,
|
|
key_part_identifier=1,
|
|
split_key_threshold=2,
|
|
split_key_method=enums.SplitKeyMethod.XOR,
|
|
prime_field_size=None
|
|
)
|
|
core_split_key = self.factory.convert(pie_split_key)
|
|
|
|
self.assertIsInstance(core_split_key, secrets.SplitKey)
|
|
self._test_core_key(
|
|
core_split_key,
|
|
enums.CryptographicAlgorithm.AES,
|
|
128,
|
|
self.symmetric_bytes,
|
|
enums.KeyFormatType.RAW
|
|
)
|
|
self.assertEqual(3, core_split_key.split_key_parts)
|
|
self.assertEqual(1, core_split_key.key_part_identifier)
|
|
self.assertEqual(2, core_split_key.split_key_threshold)
|
|
self.assertEqual(
|
|
enums.SplitKeyMethod.XOR,
|
|
core_split_key.split_key_method
|
|
)
|
|
self.assertIsNone(core_split_key.prime_field_size)
|
|
|
|
def test_convert_split_key_core_to_pie(self):
|
|
"""
|
|
Test that a core split key object can be converted into a Pie split
|
|
key object.
|
|
"""
|
|
key_block = cobjects.KeyBlock(
|
|
key_format_type=misc.KeyFormatType(enums.KeyFormatType.RAW),
|
|
key_compression_type=None,
|
|
key_value=cobjects.KeyValue(
|
|
cobjects.KeyMaterial(self.symmetric_bytes)
|
|
),
|
|
cryptographic_algorithm=attributes.CryptographicAlgorithm(
|
|
enums.CryptographicAlgorithm.AES
|
|
),
|
|
cryptographic_length=attributes.CryptographicLength(128),
|
|
key_wrapping_data=None
|
|
)
|
|
core_split_key = secrets.SplitKey(
|
|
split_key_parts=3,
|
|
key_part_identifier=1,
|
|
split_key_threshold=2,
|
|
split_key_method=enums.SplitKeyMethod.XOR,
|
|
prime_field_size=None,
|
|
key_block=key_block
|
|
)
|
|
pie_split_key = self.factory.convert(core_split_key)
|
|
|
|
self.assertIsInstance(pie_split_key, pobjects.SplitKey)
|
|
self._test_pie_key(
|
|
pie_split_key,
|
|
enums.CryptographicAlgorithm.AES,
|
|
128,
|
|
self.symmetric_bytes,
|
|
enums.KeyFormatType.RAW
|
|
)
|
|
self.assertEqual(3, pie_split_key.split_key_parts)
|
|
self.assertEqual(1, pie_split_key.key_part_identifier)
|
|
self.assertEqual(2, pie_split_key.split_key_threshold)
|
|
self.assertEqual(
|
|
enums.SplitKeyMethod.XOR,
|
|
pie_split_key.split_key_method
|
|
)
|
|
self.assertIsNone(pie_split_key.prime_field_size)
|
|
|
|
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_build_core_split_key(self):
|
|
"""
|
|
Test that a Pie split key object can be converted into a core key
|
|
object.
|
|
"""
|
|
pie_split_key = pobjects.SplitKey(
|
|
cryptographic_algorithm=enums.CryptographicAlgorithm.AES,
|
|
cryptographic_length=128,
|
|
key_value=self.symmetric_bytes,
|
|
cryptographic_usage_masks=[enums.CryptographicUsageMask.EXPORT],
|
|
name="Split Key",
|
|
key_format_type=enums.KeyFormatType.RAW,
|
|
key_wrapping_data=None,
|
|
split_key_parts=3,
|
|
key_part_identifier=1,
|
|
split_key_threshold=2,
|
|
split_key_method=enums.SplitKeyMethod.XOR,
|
|
prime_field_size=None
|
|
)
|
|
core_split_key = self.factory._build_core_split_key(pie_split_key)
|
|
|
|
self.assertIsInstance(core_split_key, secrets.SplitKey)
|
|
self._test_core_key(
|
|
core_split_key,
|
|
enums.CryptographicAlgorithm.AES,
|
|
128,
|
|
self.symmetric_bytes,
|
|
enums.KeyFormatType.RAW
|
|
)
|
|
self.assertEqual(3, core_split_key.split_key_parts)
|
|
self.assertEqual(1, core_split_key.key_part_identifier)
|
|
self.assertEqual(2, core_split_key.split_key_threshold)
|
|
self.assertEqual(
|
|
enums.SplitKeyMethod.XOR,
|
|
core_split_key.split_key_method
|
|
)
|
|
self.assertIsNone(core_split_key.prime_field_size)
|
|
|
|
def test_build_pie_split_key(self):
|
|
"""
|
|
Test that a core split key object can be converted into a Pie split
|
|
key object.
|
|
"""
|
|
key_block = cobjects.KeyBlock(
|
|
key_format_type=misc.KeyFormatType(enums.KeyFormatType.RAW),
|
|
key_compression_type=None,
|
|
key_value=cobjects.KeyValue(
|
|
cobjects.KeyMaterial(self.symmetric_bytes)
|
|
),
|
|
cryptographic_algorithm=attributes.CryptographicAlgorithm(
|
|
enums.CryptographicAlgorithm.AES
|
|
),
|
|
cryptographic_length=attributes.CryptographicLength(128),
|
|
key_wrapping_data=None
|
|
)
|
|
core_split_key = secrets.SplitKey(
|
|
split_key_parts=3,
|
|
key_part_identifier=1,
|
|
split_key_threshold=2,
|
|
split_key_method=enums.SplitKeyMethod.XOR,
|
|
prime_field_size=None,
|
|
key_block=key_block
|
|
)
|
|
pie_split_key = self.factory._build_pie_split_key(core_split_key)
|
|
|
|
self.assertIsInstance(pie_split_key, pobjects.SplitKey)
|
|
self._test_pie_key(
|
|
pie_split_key,
|
|
enums.CryptographicAlgorithm.AES,
|
|
128,
|
|
self.symmetric_bytes,
|
|
enums.KeyFormatType.RAW
|
|
)
|
|
self.assertEqual(3, pie_split_key.split_key_parts)
|
|
self.assertEqual(1, pie_split_key.key_part_identifier)
|
|
self.assertEqual(2, pie_split_key.split_key_threshold)
|
|
self.assertEqual(
|
|
enums.SplitKeyMethod.XOR,
|
|
pie_split_key.split_key_method
|
|
)
|
|
self.assertIsNone(pie_split_key.prime_field_size)
|
|
|
|
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')
|
|
)
|