From 19fcec84d8d7d21e796c7624e521b60d28ee21ed Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 20:45:59 +0200 Subject: Adding upstream version 16.2.11+ds. Signed-off-by: Daniel Baumann --- src/libkmip/tests.c | 11400 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 11400 insertions(+) create mode 100644 src/libkmip/tests.c (limited to 'src/libkmip/tests.c') diff --git a/src/libkmip/tests.c b/src/libkmip/tests.c new file mode 100644 index 000000000..c48222923 --- /dev/null +++ b/src/libkmip/tests.c @@ -0,0 +1,11400 @@ +/* Copyright (c) 2018 The Johns Hopkins University/Applied Physics Laboratory + * All Rights Reserved. + * + * This file is dual licensed under the terms of the Apache 2.0 License and + * the BSD 3-Clause License. See the LICENSE file in the root of this + * repository for more information. + */ + +#include +#include +#include "kmip.h" + + + +#define TEST_PASSED(A, B) \ +do \ +{ \ + printf("PASS - %s\n", (B)); \ + (A)->tests_passed++; \ + return(0); \ +} while(0) + +#define TEST_FAILED(A, B, C) \ +do \ +{ \ + printf("FAIL - %s @ L%d\n", (B), (C)); \ + (A)->tests_failed++; \ + return(1); \ +} while(0) + +#define TRACK_TEST(A) ((A)->test_count++) + + +typedef struct test_tracker +{ + uint16 test_count; + uint16 tests_failed; + uint16 tests_passed; +} TestTracker; + + +int +report_encoding_test_result( + TestTracker *tracker, + struct kmip *ctx, + const uint8 *expected, + const uint8 *observed, + int result, + const char *function) +{ + if(result == KMIP_OK) + { + for(size_t i = 0; i < ctx->size; i++) + { + if(expected[i] != observed[i]) + { + printf("FAIL - %s\n", function); + printf("- byte mismatch at: %zu (exp: %X, obs: %X)\n", + i, expected[i], observed[i]); + for(size_t j = 0; j < ctx->size; j++) + { + printf("- %zu: %X - %X\n", j, expected[j], observed[j]); + } + tracker->tests_failed++; + return(1); + } + } + + TEST_PASSED(tracker, function); + } + else + { + printf("FAIL - %s\n", function); + if(result == KMIP_ERROR_BUFFER_FULL) + { + printf("- context buffer is full\n"); + } + kmip_print_stack_trace(ctx); + tracker->tests_failed++; + return(1); + } +} + +int +report_decoding_test_result( + TestTracker *tracker, + struct kmip *ctx, + int comparison, + int result, + const char *function) +{ + if(result == KMIP_OK) + { + if(comparison) + { + TEST_PASSED(tracker, function); + } + else + { + printf("FAIL - %s\n", function); + printf("- compared objects are not identical\n"); + tracker->tests_failed++; + return(1); + } + } + else + { + printf("FAIL - %s\n", function); + if(result == KMIP_ERROR_BUFFER_FULL) + { + printf("- context buffer is underfull\n"); + } + kmip_print_stack_trace(ctx); + tracker->tests_failed++; + return(1); + } +} + +int +report_result(TestTracker *tracker, int observed, int expected, const char *function) +{ + if(observed == expected) + { + TEST_PASSED(tracker, function); + } + else + { + printf("FAIL - %s\n", function); + tracker->tests_failed++; + return(1); + } +} + +int +test_linked_list_push(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + LinkedList list = {0}; + + LinkedListItem a = {0}; + LinkedListItem b = {0}; + LinkedListItem c = {0}; + + if(list.head != NULL || list.tail != NULL || list.size != 0) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + kmip_linked_list_push(&list, &a); + + if(list.head != &a || list.tail != &a || list.size != 1) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + kmip_linked_list_push(&list, &b); + + if(list.head != &b || list.tail != &a || list.size != 2) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + kmip_linked_list_push(&list, &c); + + if(list.head != &c || list.tail != &a || list.size != 3) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + LinkedListItem *curr = list.head; + if(curr != &c || curr->next != &b || curr->prev != NULL) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + curr = curr->next; + if(curr != &b || curr->next != &a || curr->prev != &c) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + curr = curr->next; + if(curr != &a || curr->next != NULL || curr->prev != &b) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + TEST_PASSED(tracker, __func__); +} + +int +test_linked_list_pop(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + LinkedList list = {0}; + + if(list.head != NULL || list.tail != NULL || list.size != 0) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + LinkedListItem *item = kmip_linked_list_pop(&list); + + if(item != NULL || list.head != NULL || list.tail != NULL || list.size != 0) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + LinkedListItem a = {0}; + LinkedListItem b = {0}; + LinkedListItem c = {0}; + + a.next = &b; + a.prev = NULL; + b.next = &c; + b.prev = &a; + c.next = NULL; + c.prev = &b; + + list.head = &a; + list.tail = &c; + list.size = 3; + + item = kmip_linked_list_pop(&list); + + if(item != &a || list.head != &b || list.tail != &c || list.size != 2) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + item = kmip_linked_list_pop(&list); + + if(item != &b || list.head != &c || list.tail != &c || list.size != 1) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + item = kmip_linked_list_pop(&list); + + if(item != &c || list.head != NULL || list.tail != NULL || list.size != 0) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + TEST_PASSED(tracker, __func__); +} + +int +test_linked_list_enqueue(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + LinkedList list = {0}; + + LinkedListItem a = {0}; + LinkedListItem b = {0}; + LinkedListItem c = {0}; + + if(list.head != NULL || list.tail != NULL || list.size != 0) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + kmip_linked_list_enqueue(&list, &a); + + if(list.head != &a || list.tail != &a || list.size != 1) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + kmip_linked_list_enqueue(&list, &b); + + if(list.head != &a || list.tail != &b || list.size != 2) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + kmip_linked_list_enqueue(&list, &c); + + if(list.head != &a || list.tail != &c || list.size != 3) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + LinkedListItem *curr = list.head; + if(curr != &a || curr->next != &b || curr->prev != NULL) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + curr = curr->next; + if(curr != &b || curr->next != &c || curr->prev != &a) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + curr = curr->next; + if(curr != &c || curr->next != NULL || curr->prev != &b) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + TEST_PASSED(tracker, __func__); +} + +int +test_buffer_full_and_resize(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 expected[40] = { + 0x42, 0x00, 0x69, 0x01, 0x00, 0x00, 0x00, 0x20, + 0x42, 0x00, 0x6A, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x6B, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 too_small[30] = {0}; + uint8 large_enough[40] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, too_small, ARRAY_LENGTH(too_small), KMIP_1_0); + + struct protocol_version pv = {0}; + pv.major = 1; + pv.minor = 0; + + int result = kmip_encode_protocol_version(&ctx, &pv); + + if(result == KMIP_ERROR_BUFFER_FULL) + { + kmip_reset(&ctx); + kmip_set_buffer(&ctx, large_enough, ARRAY_LENGTH(large_enough)); + + result = kmip_encode_protocol_version(&ctx, &pv); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + large_enough, + result, + __func__); + + kmip_destroy(&ctx); + + return(result); + } + else + { + printf("FAIL - %s\n", __func__); + printf("- expected buffer full\n"); + + kmip_destroy(&ctx); + tracker->tests_failed++; + return(1); + } +} + +int +test_is_tag_next(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[3] = {0x42, 0x00, 0x08}; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0); + + uint8 *before = ctx.index; + int result = 0; + + if(kmip_is_tag_next(&ctx, KMIP_TAG_ATTRIBUTE) == KMIP_FALSE) + { + printf("FAIL - %s\n", __func__); + printf("- expected tag is not next\n"); + tracker->tests_failed++; + result = 1; + } + + uint8 *after = ctx.index; + + if(before != after) + { + printf("FAIL - %s\n", __func__); + printf("- tag checking modifies context buffer index\n"); + tracker->tests_failed++; + result = 1; + } + + kmip_destroy(&ctx); + + if(result == 0) + { + printf("PASS - %s\n", __func__); + tracker->tests_passed++; + } + + return(result); +} + +int +test_get_num_items_next(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[168] = { + 0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30, + 0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x17, + 0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, + 0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x41, 0x6C, + 0x67, 0x6F, 0x72, 0x69, 0x74, 0x68, 0x6D, 0x00, + 0x42, 0x00, 0x0B, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30, + 0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x14, + 0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, + 0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x4C, 0x65, + 0x6E, 0x67, 0x74, 0x68, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x0B, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30, + 0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x18, + 0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, + 0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x55, 0x73, + 0x61, 0x67, 0x65, 0x20, 0x4D, 0x61, 0x73, 0x6B, + 0x42, 0x00, 0x0B, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00 + }; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0); + + uint8 *before = ctx.index; + int result = 0; + int count = 0; + + count = kmip_get_num_items_next(&ctx, KMIP_TAG_ATTRIBUTE); + if(count != 3) + { + printf("FAIL - %s\n", __func__); + printf("- expected item count not found (exp. 3, obs. %d)\n", + count); + tracker->tests_failed++; + result = 1; + } + + uint8 *after = ctx.index; + + if(before != after) + { + printf("FAIL - %s\n", __func__); + printf("- item count checking modifies context buffer index\n"); + tracker->tests_failed++; + result = 1; + } + + kmip_destroy(&ctx); + + if(result == 0) + { + printf("PASS - %s\n", __func__); + tracker->tests_passed++; + } + + return(result); +} + +int +test_get_num_items_next_with_partial_item(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[136] = { + 0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30, + 0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x14, + 0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, + 0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x4C, 0x65, + 0x6E, 0x67, 0x74, 0x68, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x0B, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30, + 0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x18, + 0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, + 0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x55, 0x73, + 0x61, 0x67, 0x65, 0x20, 0x4D, 0x61, 0x73, 0x6B, + 0x42, 0x00, 0x0B, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30, + 0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x18, + 0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72 + }; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0); + + uint8 *before = ctx.index; + int result = 0; + int count = 0; + + count = kmip_get_num_items_next(&ctx, KMIP_TAG_ATTRIBUTE); + if(count != 2) + { + printf("FAIL - %s\n", __func__); + printf("- expected item count not found (exp. 2, obs. %d)\n", + count); + tracker->tests_failed++; + result = 1; + } + + uint8 *after = ctx.index; + + if(before != after) + { + printf("FAIL - %s\n", __func__); + printf("- item count checking modifies context buffer index\n"); + tracker->tests_failed++; + result = 1; + } + + kmip_destroy(&ctx); + + if(result == 0) + { + printf("PASS - %s\n", __func__); + tracker->tests_passed++; + } + + return(result); +} + +int +test_get_num_items_next_with_mismatch_item(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[80] = { + 0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30, + 0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x18, + 0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, + 0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x55, 0x73, + 0x61, 0x67, 0x65, 0x20, 0x4D, 0x61, 0x73, 0x6B, + 0x42, 0x00, 0x0B, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x20, 0x01, 0x00, 0x00, 0x00, 0x30, + 0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x18, + 0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72 + }; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0); + + uint8 *before = ctx.index; + int result = 0; + int count = 0; + + count = kmip_get_num_items_next(&ctx, KMIP_TAG_ATTRIBUTE); + if(count != 1) + { + printf("FAIL - %s\n", __func__); + printf("- expected item count not found (exp. 1, obs. %d)\n", + count); + tracker->tests_failed++; + result = 1; + } + + uint8 *after = ctx.index; + + if(before != after) + { + printf("FAIL - %s\n", __func__); + printf("- item count checking modifies context buffer index\n"); + tracker->tests_failed++; + result = 1; + } + + kmip_destroy(&ctx); + + if(result == 0) + { + printf("PASS - %s\n", __func__); + tracker->tests_passed++; + } + + return(result); +} + +int +test_get_num_items_next_with_no_matches(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[80] = { + 0x42, 0x00, 0x20, 0x01, 0x00, 0x00, 0x00, 0x30, + 0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x18, + 0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, + 0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x55, 0x73, + 0x61, 0x67, 0x65, 0x20, 0x4D, 0x61, 0x73, 0x6B, + 0x42, 0x00, 0x0B, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x20, 0x01, 0x00, 0x00, 0x00, 0x30, + 0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x18, + 0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72 + }; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0); + + uint8 *before = ctx.index; + int result = 0; + int count = 0; + + count = kmip_get_num_items_next(&ctx, KMIP_TAG_ATTRIBUTE); + if(count != 0) + { + printf("FAIL - %s\n", __func__); + printf("- expected item count not found (exp. 0, obs. %d)\n", + count); + tracker->tests_failed++; + result = 1; + } + + uint8 *after = ctx.index; + + if(before != after) + { + printf("FAIL - %s\n", __func__); + printf("- item count checking modifies context buffer index\n"); + tracker->tests_failed++; + result = 1; + } + + kmip_destroy(&ctx); + + if(result == 0) + { + printf("PASS - %s\n", __func__); + tracker->tests_passed++; + } + + return(result); +} + +int +test_get_num_items_next_with_non_structures(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[144] = { + 0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x26, + 0x31, 0x30, 0x30, 0x31, 0x38, 0x32, 0x64, 0x35, + 0x2D, 0x37, 0x32, 0x62, 0x38, 0x2D, 0x34, 0x37, + 0x61, 0x61, 0x2D, 0x38, 0x33, 0x38, 0x33, 0x2D, + 0x34, 0x64, 0x39, 0x37, 0x64, 0x35, 0x31, 0x32, + 0x65, 0x39, 0x38, 0x61, 0x11, 0x11, 0x00, 0x00, + 0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x25, + 0x31, 0x30, 0x30, 0x31, 0x38, 0x32, 0x64, 0x35, + 0x2D, 0x37, 0x32, 0x62, 0x38, 0x2D, 0x34, 0x37, + 0x61, 0x61, 0x2D, 0x38, 0x33, 0x38, 0x33, 0x2D, + 0x34, 0x64, 0x39, 0x37, 0x64, 0x35, 0x31, 0x32, + 0x65, 0x39, 0x38, 0x61, 0x11, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, + 0x31, 0x30, 0x30, 0x31, 0x38, 0x32, 0x64, 0x35, + 0x2D, 0x37, 0x32, 0x62, 0x38, 0x2D, 0x34, 0x37, + 0x61, 0x61, 0x2D, 0x38, 0x33, 0x38, 0x33, 0x2D, + 0x34, 0x64, 0x39, 0x37, 0x64, 0x35, 0x31, 0x32, + 0x65, 0x39, 0x38, 0x61, 0x00, 0x00, 0x00, 0x00 + }; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0); + + uint8 *before = ctx.index; + int result = 0; + int count = 0; + + count = kmip_get_num_items_next(&ctx, KMIP_TAG_UNIQUE_IDENTIFIER); + if(count != 3) + { + printf("FAIL - %s\n", __func__); + printf("- expected item count not found (exp. 3, obs. %d)\n", + count); + tracker->tests_failed++; + result = 1; + } + + uint8 *after = ctx.index; + + if(before != after) + { + printf("FAIL - %s\n", __func__); + printf("- item count checking modifies context buffer index\n"); + tracker->tests_failed++; + result = 1; + } + + kmip_destroy(&ctx); + + if(result == 0) + { + printf("PASS - %s\n", __func__); + tracker->tests_passed++; + } + + return(result); +} + +int +test_buffer_bytes_left(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 a[1] = {0x42}; + uint8 b[3] = {0x42, 0x00, 0x08}; + uint8 c[5] = {0x42, 0x00, 0x53, 0x01, 0x00}; + + KMIP ctx = {0}; + kmip_init(&ctx, a, ARRAY_LENGTH(a), KMIP_1_0); + + if(BUFFER_BYTES_LEFT(&ctx) != 1) + { + kmip_destroy(&ctx); + TEST_FAILED(tracker, __func__, __LINE__); + } + + kmip_destroy(&ctx); + kmip_init(&ctx, b, ARRAY_LENGTH(b), KMIP_1_0); + + if(BUFFER_BYTES_LEFT(&ctx) != 3) + { + kmip_destroy(&ctx); + TEST_FAILED(tracker, __func__, __LINE__); + } + + kmip_destroy(&ctx); + kmip_init(&ctx, c, ARRAY_LENGTH(c), KMIP_1_0); + + if(BUFFER_BYTES_LEFT(&ctx) != 5) + { + kmip_destroy(&ctx); + TEST_FAILED(tracker, __func__, __LINE__); + } + + kmip_destroy(&ctx); + + TEST_PASSED(tracker, __func__); +} + +int +test_get_num_attributes_next(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + /* Need to build an encoding with one of each type of support + attribute. Verify that this function returns the correct + count. + + Need to build an encoding with bad attribute length? Handle + weird corner cases? + */ + TEST_FAILED(tracker, __func__, __LINE__); +} + +int +test_peek_tag(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + /* Build an encoding with an arbitrary tag value. Verify that this + function reads and returns this tag value without changing the + context buffer. + */ + + uint8 underfull_encoding[1] = {0x42}; + uint8 full_encoding[3] = {0x42, 0x00, 0x08}; + uint8 overfull_encoding[5] = {0x42, 0x00, 0x53, 0x01, 0x00}; + + uint32 tag = 0; + uint8 *prev_buffer = NULL; + uint8 *prev_index = NULL; + size_t prev_size = 0; + KMIP ctx = {0}; + kmip_init(&ctx, underfull_encoding, ARRAY_LENGTH(underfull_encoding), KMIP_1_0); + + prev_buffer = ctx.buffer; + prev_index = ctx.index; + prev_size = ctx.size; + tag = kmip_peek_tag(&ctx); + if(tag != 0 || ctx.buffer != prev_buffer || ctx.index != prev_index || ctx.size != prev_size) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + kmip_destroy(&ctx); + kmip_init(&ctx, full_encoding, ARRAY_LENGTH(full_encoding), KMIP_1_0); + + prev_buffer = ctx.buffer; + prev_index = ctx.index; + prev_size = ctx.size; + tag = kmip_peek_tag(&ctx); + if(tag != KMIP_TAG_ATTRIBUTE || ctx.buffer != prev_buffer || ctx.index != prev_index || ctx.size != prev_size) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + kmip_destroy(&ctx); + kmip_init(&ctx, overfull_encoding, ARRAY_LENGTH(overfull_encoding), KMIP_1_0); + + prev_buffer = ctx.buffer; + prev_index = ctx.index; + prev_size = ctx.size; + tag = kmip_peek_tag(&ctx); + if(tag != KMIP_TAG_NAME || ctx.buffer != prev_buffer || ctx.index != prev_index || ctx.size != prev_size) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + kmip_destroy(&ctx); + + TEST_PASSED(tracker, __func__); +} + +int +test_is_attribute_tag(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + if(!kmip_is_attribute_tag(KMIP_TAG_UNIQUE_IDENTIFIER)) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + if(!kmip_is_attribute_tag(KMIP_TAG_NAME)) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + if(!kmip_is_attribute_tag(KMIP_TAG_OBJECT_TYPE)) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + if(!kmip_is_attribute_tag(KMIP_TAG_CRYPTOGRAPHIC_ALGORITHM)) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + if(!kmip_is_attribute_tag(KMIP_TAG_CRYPTOGRAPHIC_LENGTH)) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + if(!kmip_is_attribute_tag(KMIP_TAG_CRYPTOGRAPHIC_PARAMETERS)) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + if(!kmip_is_attribute_tag(KMIP_TAG_CRYPTOGRAPHIC_DOMAIN_PARAMETERS)) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + if(!kmip_is_attribute_tag(KMIP_TAG_CERTIFICATE_TYPE)) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + if(!kmip_is_attribute_tag(KMIP_TAG_CERTIFICATE_LENGTH)) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + if(!kmip_is_attribute_tag(KMIP_TAG_X509_CERTIFICATE_IDENTIFIER)) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + if(!kmip_is_attribute_tag(KMIP_TAG_X509_CERTIFICATE_SUBJECT)) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + if(!kmip_is_attribute_tag(KMIP_TAG_X509_CERTIFICATE_ISSUER)) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + if(!kmip_is_attribute_tag(KMIP_TAG_CERTIFICATE_IDENTIFIER)) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + if(!kmip_is_attribute_tag(KMIP_TAG_CERTIFICATE_SUBJECT)) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + if(!kmip_is_attribute_tag(KMIP_TAG_CERTIFICATE_ISSUER)) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + if(!kmip_is_attribute_tag(KMIP_TAG_DIGITAL_SIGNATURE_ALGORITHM)) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + if(!kmip_is_attribute_tag(KMIP_TAG_DIGEST)) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + if(!kmip_is_attribute_tag(KMIP_TAG_OPERATION_POLICY_NAME)) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + if(!kmip_is_attribute_tag(KMIP_TAG_CRYPTOGRAPHIC_USAGE_MASK)) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + if(!kmip_is_attribute_tag(KMIP_TAG_LEASE_TIME)) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + if(!kmip_is_attribute_tag(KMIP_TAG_USAGE_LIMITS)) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + if(!kmip_is_attribute_tag(KMIP_TAG_STATE)) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + if(!kmip_is_attribute_tag(KMIP_TAG_INITIAL_DATE)) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + if(!kmip_is_attribute_tag(KMIP_TAG_ACTIVATION_DATE)) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + if(!kmip_is_attribute_tag(KMIP_TAG_PROCESS_START_DATE)) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + if(!kmip_is_attribute_tag(KMIP_TAG_PROTECT_STOP_DATE)) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + if(!kmip_is_attribute_tag(KMIP_TAG_DEACTIVATION_DATE)) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + if(!kmip_is_attribute_tag(KMIP_TAG_DESTROY_DATE)) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + if(!kmip_is_attribute_tag(KMIP_TAG_COMPROMISE_OCCURRENCE_DATE)) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + if(!kmip_is_attribute_tag(KMIP_TAG_COMPROMISE_DATE)) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + if(!kmip_is_attribute_tag(KMIP_TAG_REVOCATION_REASON)) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + if(!kmip_is_attribute_tag(KMIP_TAG_ARCHIVE_DATE)) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + if(!kmip_is_attribute_tag(KMIP_TAG_OBJECT_GROUP)) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + if(!kmip_is_attribute_tag(KMIP_TAG_FRESH)) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + if(!kmip_is_attribute_tag(KMIP_TAG_LINK)) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + if(!kmip_is_attribute_tag(KMIP_TAG_APPLICATION_SPECIFIC_INFORMATION)) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + if(!kmip_is_attribute_tag(KMIP_TAG_CONTACT_INFORMATION)) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + if(!kmip_is_attribute_tag(KMIP_TAG_LAST_CHANGE_DATE)) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + if(!kmip_is_attribute_tag(KMIP_TAG_ALTERNATIVE_NAME)) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + if(!kmip_is_attribute_tag(KMIP_TAG_KEY_VALUE_PRESENT)) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + if(!kmip_is_attribute_tag(KMIP_TAG_KEY_VALUE_LOCATION)) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + if(!kmip_is_attribute_tag(KMIP_TAG_ORIGINAL_CREATION_DATE)) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + if(!kmip_is_attribute_tag(KMIP_TAG_RANDOM_NUMBER_GENERATOR)) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + if(!kmip_is_attribute_tag(KMIP_TAG_PKCS_12_FRIENDLY_NAME)) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + if(!kmip_is_attribute_tag(KMIP_TAG_DESCRIPTION)) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + if(!kmip_is_attribute_tag(KMIP_TAG_COMMENT)) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + if(!kmip_is_attribute_tag(KMIP_TAG_SENSITIVE)) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + if(!kmip_is_attribute_tag(KMIP_TAG_ALWAYS_SENSITIVE)) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + if(!kmip_is_attribute_tag(KMIP_TAG_EXTRACTABLE)) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + if(!kmip_is_attribute_tag(KMIP_TAG_NEVER_EXTRACTABLE)) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + if(!kmip_is_attribute_tag(KMIP_TAG_KEY_FORMAT_TYPE)) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_is_attribute_tag(KMIP_TAG_REQUEST_MESSAGE)) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + TEST_PASSED(tracker, __func__); +} + +int +test_get_enum_string_index(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + if(kmip_get_enum_string_index(KMIP_TAG_UNIQUE_IDENTIFIER) != 0) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_get_enum_string_index(KMIP_TAG_NAME) != 1) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_get_enum_string_index(KMIP_TAG_OBJECT_TYPE) != 2) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_get_enum_string_index(KMIP_TAG_CRYPTOGRAPHIC_ALGORITHM) != 3) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_get_enum_string_index(KMIP_TAG_CRYPTOGRAPHIC_LENGTH) != 4) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_get_enum_string_index(KMIP_TAG_CRYPTOGRAPHIC_PARAMETERS) != 5) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_get_enum_string_index(KMIP_TAG_CRYPTOGRAPHIC_DOMAIN_PARAMETERS) != 6) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_get_enum_string_index(KMIP_TAG_CERTIFICATE_TYPE) != 7) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_get_enum_string_index(KMIP_TAG_CERTIFICATE_LENGTH) != 8) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_get_enum_string_index(KMIP_TAG_X509_CERTIFICATE_IDENTIFIER) != 9) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_get_enum_string_index(KMIP_TAG_X509_CERTIFICATE_SUBJECT) != 10) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_get_enum_string_index(KMIP_TAG_X509_CERTIFICATE_ISSUER) != 11) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_get_enum_string_index(KMIP_TAG_CERTIFICATE_IDENTIFIER) != 12) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_get_enum_string_index(KMIP_TAG_CERTIFICATE_SUBJECT) != 13) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_get_enum_string_index(KMIP_TAG_CERTIFICATE_ISSUER) != 14) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_get_enum_string_index(KMIP_TAG_DIGITAL_SIGNATURE_ALGORITHM) != 15) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_get_enum_string_index(KMIP_TAG_DIGEST) != 16) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_get_enum_string_index(KMIP_TAG_OPERATION_POLICY_NAME) != 17) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_get_enum_string_index(KMIP_TAG_CRYPTOGRAPHIC_USAGE_MASK) != 18) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_get_enum_string_index(KMIP_TAG_LEASE_TIME) != 19) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_get_enum_string_index(KMIP_TAG_USAGE_LIMITS) != 20) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_get_enum_string_index(KMIP_TAG_STATE) != 21) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_get_enum_string_index(KMIP_TAG_INITIAL_DATE) != 22) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_get_enum_string_index(KMIP_TAG_ACTIVATION_DATE) != 23) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_get_enum_string_index(KMIP_TAG_PROCESS_START_DATE) != 24) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_get_enum_string_index(KMIP_TAG_PROTECT_STOP_DATE) != 25) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_get_enum_string_index(KMIP_TAG_DEACTIVATION_DATE) != 26) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_get_enum_string_index(KMIP_TAG_DESTROY_DATE) != 27) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_get_enum_string_index(KMIP_TAG_COMPROMISE_OCCURRENCE_DATE) != 28) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_get_enum_string_index(KMIP_TAG_COMPROMISE_DATE) != 29) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_get_enum_string_index(KMIP_TAG_REVOCATION_REASON) != 30) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_get_enum_string_index(KMIP_TAG_ARCHIVE_DATE) != 31) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_get_enum_string_index(KMIP_TAG_OBJECT_GROUP) != 32) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_get_enum_string_index(KMIP_TAG_FRESH) != 33) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_get_enum_string_index(KMIP_TAG_LINK) != 34) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_get_enum_string_index(KMIP_TAG_APPLICATION_SPECIFIC_INFORMATION) != 35) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_get_enum_string_index(KMIP_TAG_CONTACT_INFORMATION) != 36) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_get_enum_string_index(KMIP_TAG_LAST_CHANGE_DATE) != 37) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_get_enum_string_index(KMIP_TAG_ALTERNATIVE_NAME) != 38) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_get_enum_string_index(KMIP_TAG_KEY_VALUE_PRESENT) != 39) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_get_enum_string_index(KMIP_TAG_KEY_VALUE_LOCATION) != 40) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_get_enum_string_index(KMIP_TAG_ORIGINAL_CREATION_DATE) != 41) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_get_enum_string_index(KMIP_TAG_RANDOM_NUMBER_GENERATOR) != 42) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_get_enum_string_index(KMIP_TAG_PKCS_12_FRIENDLY_NAME) != 43) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_get_enum_string_index(KMIP_TAG_DESCRIPTION) != 44) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_get_enum_string_index(KMIP_TAG_COMMENT) != 45) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_get_enum_string_index(KMIP_TAG_SENSITIVE) != 46) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_get_enum_string_index(KMIP_TAG_ALWAYS_SENSITIVE) != 47) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_get_enum_string_index(KMIP_TAG_EXTRACTABLE) != 48) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_get_enum_string_index(KMIP_TAG_NEVER_EXTRACTABLE) != 49) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_get_enum_string_index(KMIP_TAG_KEY_FORMAT_TYPE) != 50) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_get_enum_string_index(-1) != 51) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + TEST_PASSED(tracker, __func__); +} + +int +test_check_enum_value_protection_storage_masks(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + enum kmip_version v = KMIP_2_0; + enum tag t = KMIP_TAG_PROTECTION_STORAGE_MASK; + + if(kmip_check_enum_value(v, t, KMIP_PROTECT_SOFTWARE) != KMIP_OK) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_check_enum_value(v, t, KMIP_PROTECT_HARDWARE) != KMIP_OK) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_check_enum_value(v, t, KMIP_PROTECT_ON_PROCESSOR) != KMIP_OK) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_check_enum_value(v, t, KMIP_PROTECT_ON_SYSTEM) != KMIP_OK) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_check_enum_value(v, t, KMIP_PROTECT_OFF_SYSTEM) != KMIP_OK) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_check_enum_value(v, t, KMIP_PROTECT_HYPERVISOR) != KMIP_OK) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_check_enum_value(v, t, KMIP_PROTECT_OPERATING_SYSTEM) != KMIP_OK) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_check_enum_value(v, t, KMIP_PROTECT_CONTAINER) != KMIP_OK) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_check_enum_value(v, t, KMIP_PROTECT_ON_PREMISES) != KMIP_OK) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_check_enum_value(v, t, KMIP_PROTECT_OFF_PREMISES) != KMIP_OK) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_check_enum_value(v, t, KMIP_PROTECT_SELF_MANAGED) != KMIP_OK) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_check_enum_value(v, t, KMIP_PROTECT_OUTSOURCED) != KMIP_OK) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_check_enum_value(v, t, KMIP_PROTECT_VALIDATED) != KMIP_OK) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_check_enum_value(v, t, KMIP_PROTECT_SAME_JURISDICTION) != KMIP_OK) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + v = KMIP_1_4; + + if(kmip_check_enum_value(v, t, KMIP_PROTECT_SOFTWARE) != KMIP_INVALID_FOR_VERSION) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_check_enum_value(v, t, KMIP_PROTECT_HARDWARE) != KMIP_INVALID_FOR_VERSION) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_check_enum_value(v, t, KMIP_PROTECT_ON_PROCESSOR) != KMIP_INVALID_FOR_VERSION) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_check_enum_value(v, t, KMIP_PROTECT_ON_SYSTEM) != KMIP_INVALID_FOR_VERSION) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_check_enum_value(v, t, KMIP_PROTECT_OFF_SYSTEM) != KMIP_INVALID_FOR_VERSION) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_check_enum_value(v, t, KMIP_PROTECT_HYPERVISOR) != KMIP_INVALID_FOR_VERSION) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_check_enum_value(v, t, KMIP_PROTECT_OPERATING_SYSTEM) != KMIP_INVALID_FOR_VERSION) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_check_enum_value(v, t, KMIP_PROTECT_CONTAINER) != KMIP_INVALID_FOR_VERSION) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_check_enum_value(v, t, KMIP_PROTECT_ON_PREMISES) != KMIP_INVALID_FOR_VERSION) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_check_enum_value(v, t, KMIP_PROTECT_OFF_PREMISES) != KMIP_INVALID_FOR_VERSION) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_check_enum_value(v, t, KMIP_PROTECT_SELF_MANAGED) != KMIP_INVALID_FOR_VERSION) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_check_enum_value(v, t, KMIP_PROTECT_OUTSOURCED) != KMIP_INVALID_FOR_VERSION) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_check_enum_value(v, t, KMIP_PROTECT_VALIDATED) != KMIP_INVALID_FOR_VERSION) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_check_enum_value(v, t, KMIP_PROTECT_SAME_JURISDICTION) != KMIP_INVALID_FOR_VERSION) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + if(kmip_check_enum_value(v, t, -1) != KMIP_ENUM_MISMATCH) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + TEST_PASSED(tracker, __func__); +} + +int +test_init_protocol_version(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + kmip_init_protocol_version(NULL, KMIP_1_0); + + ProtocolVersion pv = {0}; + + if(pv.major != 0) + TEST_FAILED(tracker, __func__, __LINE__); + if(pv.minor != 0) + TEST_FAILED(tracker, __func__, __LINE__); + + kmip_init_protocol_version(&pv, KMIP_1_0); + + if(pv.major != 1) + TEST_FAILED(tracker, __func__, __LINE__); + if(pv.minor != 0) + TEST_FAILED(tracker, __func__, __LINE__); + + kmip_init_protocol_version(&pv, KMIP_1_1); + + if(pv.major != 1) + TEST_FAILED(tracker, __func__, __LINE__); + if(pv.minor != 1) + TEST_FAILED(tracker, __func__, __LINE__); + + kmip_init_protocol_version(&pv, KMIP_1_2); + + if(pv.major != 1) + TEST_FAILED(tracker, __func__, __LINE__); + if(pv.minor != 2) + TEST_FAILED(tracker, __func__, __LINE__); + + kmip_init_protocol_version(&pv, KMIP_1_3); + + if(pv.major != 1) + TEST_FAILED(tracker, __func__, __LINE__); + if(pv.minor != 3) + TEST_FAILED(tracker, __func__, __LINE__); + + kmip_init_protocol_version(&pv, KMIP_1_4); + + if(pv.major != 1) + TEST_FAILED(tracker, __func__, __LINE__); + if(pv.minor != 4) + TEST_FAILED(tracker, __func__, __LINE__); + + kmip_init_protocol_version(&pv, KMIP_2_0); + + if(pv.major != 2) + TEST_FAILED(tracker, __func__, __LINE__); + if(pv.minor != 0) + TEST_FAILED(tracker, __func__, __LINE__); + + TEST_PASSED(tracker, __func__); +} + +int +test_init_request_batch_item(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + kmip_init_request_batch_item(NULL); + + RequestBatchItem rbi = {0}; + + if(rbi.operation != 0) + TEST_FAILED(tracker, __func__, __LINE__); + if(rbi.unique_batch_item_id != NULL) + TEST_FAILED(tracker, __func__, __LINE__); + if(rbi.request_payload != NULL) + TEST_FAILED(tracker, __func__, __LINE__); + if(rbi.ephemeral != 0) + TEST_FAILED(tracker, __func__, __LINE__); + + kmip_init_request_batch_item(&rbi); + + if(rbi.operation != 0) + TEST_FAILED(tracker, __func__, __LINE__); + if(rbi.unique_batch_item_id != NULL) + TEST_FAILED(tracker, __func__, __LINE__); + if(rbi.request_payload != NULL) + TEST_FAILED(tracker, __func__, __LINE__); + if(rbi.ephemeral != KMIP_UNSET) + TEST_FAILED(tracker, __func__, __LINE__); + + TEST_PASSED(tracker, __func__); +} + +int +test_print_attributes(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + /* For now this will probably be left as a placeholder for a + future test. Ideally the print functions would output to + an arbitrary buffer so that we can verify that they are + correctly displaying structure content and formatting. + Since they currently use printf directly, this may be hard + to do in the short term. + */ + TEST_FAILED(tracker, __func__, __LINE__); +} + +int +test_free_attributes(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + /* Build a dynamically allocated Attributes structure. Free it + with this function. Verify that all internal pointers and + fields are correctly nullified. + + Ideally, hook into the free function managed by the context + and use that hook to verify that the correct free calls are + made on the internal Attributes structure pointers. This + may require more infrastructure work than currently exists. + */ + TEST_FAILED(tracker, __func__, __LINE__); +} + +int +test_compare_attributes(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + /* Build two separate identical Attributes structures. Compare + them with this function and confirm they match. + + Build two separate different Attributes structures. Compare + them with this function and confirm they do not match. This + may require multiple rounds, changing different parts of the + underlying Attributes structure. It may make more sense to + split this into multiple test functions. + */ + TEST_FAILED(tracker, __func__, __LINE__); +} + +int +test_deep_copy_int32(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + int32 expected = 42; + int32 *observed = NULL; + + observed = kmip_deep_copy_int32(NULL, NULL); + if(observed != NULL) + TEST_FAILED(tracker, __func__, __LINE__); + + KMIP ctx = {0}; + kmip_init(&ctx, NULL, 0, KMIP_1_0); + + observed = kmip_deep_copy_int32(&ctx, NULL); + if(observed != NULL) + { + kmip_destroy(&ctx); + TEST_FAILED(tracker, __func__, __LINE__); + } + + observed = kmip_deep_copy_int32(&ctx, &expected); + if(observed == NULL) + { + kmip_destroy(&ctx); + TEST_FAILED(tracker, __func__, __LINE__); + } + if(*observed != expected) + { + kmip_print_integer(expected); + kmip_print_integer(*observed); + ctx.free_func(ctx.state, observed); + kmip_destroy(&ctx); + TEST_FAILED(tracker, __func__, __LINE__); + } + + ctx.free_func(ctx.state, observed); + kmip_destroy(&ctx); + + TEST_PASSED(tracker, __func__); +} + +int +test_deep_copy_text_string(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + TextString expected = {0}; + expected.value = "example"; + expected.size = 7; + TextString *observed = NULL; + + observed = kmip_deep_copy_text_string(NULL, NULL); + if(observed != NULL) + TEST_FAILED(tracker, __func__, __LINE__); + + KMIP ctx = {0}; + kmip_init(&ctx, NULL, 0, KMIP_1_0); + + observed = kmip_deep_copy_text_string(&ctx, NULL); + if(observed != NULL) + { + kmip_destroy(&ctx); + TEST_FAILED(tracker, __func__, __LINE__); + } + + observed = kmip_deep_copy_text_string(&ctx, &expected); + if(observed == NULL) + { + kmip_destroy(&ctx); + TEST_FAILED(tracker, __func__, __LINE__); + } + if(!kmip_compare_text_string(&expected, observed)) + { + kmip_print_text_string(1, "Name Value", &expected); + kmip_print_text_string(1, "Name Value", observed); + kmip_free_text_string(&ctx, observed); + ctx.free_func(ctx.state, observed); + kmip_destroy(&ctx); + TEST_FAILED(tracker, __func__, __LINE__); + } + + kmip_free_text_string(&ctx, observed); + ctx.free_func(ctx.state, observed); + kmip_destroy(&ctx); + + TEST_PASSED(tracker, __func__); +} + +int +test_deep_copy_name(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + TextString value = {0}; + value.value = "example"; + value.size = 7; + Name expected = {0}; + expected.value = &value; + expected.type = KMIP_NAME_UNINTERPRETED_TEXT_STRING; + Name *observed = NULL; + + observed = kmip_deep_copy_name(NULL, NULL); + if(observed != NULL) + TEST_FAILED(tracker, __func__, __LINE__); + + KMIP ctx = {0}; + kmip_init(&ctx, NULL, 0, KMIP_1_0); + + observed = kmip_deep_copy_name(&ctx, NULL); + if(observed != NULL) + { + kmip_destroy(&ctx); + TEST_FAILED(tracker, __func__, __LINE__); + } + + observed = kmip_deep_copy_name(&ctx, &expected); + if(observed == NULL) + { + kmip_destroy(&ctx); + TEST_FAILED(tracker, __func__, __LINE__); + } + if(!kmip_compare_name(&expected, observed)) + { + kmip_print_name(1, &expected); + kmip_print_name(1, observed); + kmip_free_name(&ctx, observed); + ctx.free_func(ctx.state, observed); + kmip_destroy(&ctx); + TEST_FAILED(tracker, __func__, __LINE__); + } + + kmip_free_name(&ctx, observed); + ctx.free_func(ctx.state, observed); + kmip_destroy(&ctx); + + TEST_PASSED(tracker, __func__); +} + +int +test_deep_copy_attribute(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + Attribute expected = {0}; + kmip_init_attribute(&expected); + Attribute *observed = NULL; + + observed = kmip_deep_copy_attribute(NULL, NULL); + if(observed != NULL) + TEST_FAILED(tracker, __func__, __LINE__); + + KMIP ctx = {0}; + kmip_init(&ctx, NULL, 0, KMIP_1_0); + + observed = kmip_deep_copy_attribute(&ctx, NULL); + if(observed != NULL) + { + kmip_destroy(&ctx); + TEST_FAILED(tracker, __func__, __LINE__); + } + + /* Test deep copying an "empty" attribute. */ + observed = kmip_deep_copy_attribute(&ctx, &expected); + if(observed == NULL) + { + kmip_destroy(&ctx); + TEST_FAILED(tracker, __func__, __LINE__); + } + if(!kmip_compare_attribute(&expected, observed)) + { + kmip_print_attribute(1, &expected); + kmip_print_attribute(1, observed); + kmip_free_attribute(&ctx, observed); + ctx.free_func(ctx.state, observed); + kmip_destroy(&ctx); + TEST_FAILED(tracker, __func__, __LINE__); + } + + kmip_free_attribute(&ctx, observed); + ctx.free_func(ctx.state, observed); + + /* Test deep copying a Unique Identifier attribute. */ + TextString uuid = {0}; + uuid.value = "49a1ca88-6bea-4fb2-b450-7e58802c3038"; + uuid.size = 36; + expected.type = KMIP_ATTR_UNIQUE_IDENTIFIER; + expected.value = &uuid; + + observed = kmip_deep_copy_attribute(&ctx, &expected); + if(observed == NULL) + { + kmip_destroy(&ctx); + TEST_FAILED(tracker, __func__, __LINE__); + } + if(!kmip_compare_attribute(&expected, observed)) + { + kmip_print_attribute(1, &expected); + kmip_print_attribute(1, observed); + kmip_free_attribute(&ctx, observed); + ctx.free_func(ctx.state, observed); + kmip_destroy(&ctx); + TEST_FAILED(tracker, __func__, __LINE__); + } + + kmip_free_attribute(&ctx, observed); + ctx.free_func(ctx.state, observed); + + /* Test deep copying an Operation Policy Name attribute. */ + TextString policy = {0}; + policy.value = "default"; + policy.size = 7; + expected.type = KMIP_ATTR_OPERATION_POLICY_NAME; + expected.value = &policy; + + observed = kmip_deep_copy_attribute(&ctx, &expected); + if(observed == NULL) + { + kmip_destroy(&ctx); + TEST_FAILED(tracker, __func__, __LINE__); + } + if(!kmip_compare_attribute(&expected, observed)) + { + kmip_print_attribute(1, &expected); + kmip_print_attribute(1, observed); + kmip_free_attribute(&ctx, observed); + ctx.free_func(ctx.state, observed); + kmip_destroy(&ctx); + TEST_FAILED(tracker, __func__, __LINE__); + } + + kmip_free_attribute(&ctx, observed); + ctx.free_func(ctx.state, observed); + + /* Test deep copying a Name attribute. */ + TextString name_value = {0}; + name_value.value = "example"; + name_value.size = 7; + Name name = {0}; + name.value = &name_value; + name.type = KMIP_NAME_UNINTERPRETED_TEXT_STRING; + expected.type = KMIP_ATTR_NAME; + expected.value = &name; + + observed = kmip_deep_copy_attribute(&ctx, &expected); + if(observed == NULL) + { + kmip_destroy(&ctx); + TEST_FAILED(tracker, __func__, __LINE__); + } + if(!kmip_compare_attribute(&expected, observed)) + { + kmip_print_attribute(1, &expected); + kmip_print_attribute(1, observed); + kmip_free_attribute(&ctx, observed); + ctx.free_func(ctx.state, observed); + kmip_destroy(&ctx); + TEST_FAILED(tracker, __func__, __LINE__); + } + + kmip_free_attribute(&ctx, observed); + ctx.free_func(ctx.state, observed); + + /* Test deep copying an Object Type attribute. */ + enum object_type object_type = KMIP_OBJTYPE_SYMMETRIC_KEY; + expected.type = KMIP_ATTR_OBJECT_TYPE; + expected.value = &object_type; + + observed = kmip_deep_copy_attribute(&ctx, &expected); + if(observed == NULL) + { + kmip_destroy(&ctx); + TEST_FAILED(tracker, __func__, __LINE__); + } + if(!kmip_compare_attribute(&expected, observed)) + { + kmip_print_attribute(1, &expected); + kmip_print_attribute(1, observed); + kmip_free_attribute(&ctx, observed); + ctx.free_func(ctx.state, observed); + kmip_destroy(&ctx); + TEST_FAILED(tracker, __func__, __LINE__); + } + + kmip_free_attribute(&ctx, observed); + ctx.free_func(ctx.state, observed); + + /* Test deep copying a Cryptographic Algorithm attribute. */ + enum cryptographic_algorithm cryptographic_algorithm = KMIP_CRYPTOALG_AES; + expected.type = KMIP_ATTR_CRYPTOGRAPHIC_ALGORITHM; + expected.value = &cryptographic_algorithm; + + observed = kmip_deep_copy_attribute(&ctx, &expected); + if(observed == NULL) + { + kmip_destroy(&ctx); + TEST_FAILED(tracker, __func__, __LINE__); + } + if(!kmip_compare_attribute(&expected, observed)) + { + kmip_print_attribute(1, &expected); + kmip_print_attribute(1, observed); + kmip_free_attribute(&ctx, observed); + ctx.free_func(ctx.state, observed); + kmip_destroy(&ctx); + TEST_FAILED(tracker, __func__, __LINE__); + } + + kmip_free_attribute(&ctx, observed); + ctx.free_func(ctx.state, observed); + + /* Test deep copying a Cryptographic Length attribute. */ + int32 cryptographic_length = 256; + expected.type = KMIP_ATTR_CRYPTOGRAPHIC_LENGTH; + expected.value = &cryptographic_length; + + observed = kmip_deep_copy_attribute(&ctx, &expected); + if(observed == NULL) + { + kmip_destroy(&ctx); + TEST_FAILED(tracker, __func__, __LINE__); + } + if(!kmip_compare_attribute(&expected, observed)) + { + kmip_print_attribute(1, &expected); + kmip_print_attribute(1, observed); + kmip_free_attribute(&ctx, observed); + ctx.free_func(ctx.state, observed); + kmip_destroy(&ctx); + TEST_FAILED(tracker, __func__, __LINE__); + } + + kmip_free_attribute(&ctx, observed); + ctx.free_func(ctx.state, observed); + + /* Test deep copying a Cryptographic Usage Mask attribute. */ + int32 cryptographic_usage_mask = KMIP_CRYPTOMASK_ENCRYPT | KMIP_CRYPTOMASK_DECRYPT; + expected.type = KMIP_ATTR_CRYPTOGRAPHIC_USAGE_MASK; + expected.value = &cryptographic_usage_mask; + + observed = kmip_deep_copy_attribute(&ctx, &expected); + if(observed == NULL) + { + kmip_destroy(&ctx); + TEST_FAILED(tracker, __func__, __LINE__); + } + if(!kmip_compare_attribute(&expected, observed)) + { + kmip_print_attribute(1, &expected); + kmip_print_attribute(1, observed); + kmip_free_attribute(&ctx, observed); + ctx.free_func(ctx.state, observed); + kmip_destroy(&ctx); + TEST_FAILED(tracker, __func__, __LINE__); + } + + kmip_free_attribute(&ctx, observed); + ctx.free_func(ctx.state, observed); + + /* Test deep copying a State attribute. */ + enum state state = KMIP_STATE_ACTIVE; + expected.type = KMIP_ATTR_STATE; + expected.value = &state; + + observed = kmip_deep_copy_attribute(&ctx, &expected); + if(observed == NULL) + { + kmip_destroy(&ctx); + TEST_FAILED(tracker, __func__, __LINE__); + } + if(!kmip_compare_attribute(&expected, observed)) + { + kmip_print_attribute(1, &expected); + kmip_print_attribute(1, observed); + kmip_free_attribute(&ctx, observed); + ctx.free_func(ctx.state, observed); + kmip_destroy(&ctx); + TEST_FAILED(tracker, __func__, __LINE__); + } + + kmip_free_attribute(&ctx, observed); + ctx.free_func(ctx.state, observed); + kmip_destroy(&ctx); + + TEST_PASSED(tracker, __func__); +} + +int +test_decode_int8_be(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[1] = {0x42}; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0); + + int8 value = 0; + + int result = kmip_decode_int8_be(&ctx, &value); + result = report_decoding_test_result( + tracker, + &ctx, + value == 0x42, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_decode_int32_be(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[4] = {0x11, 0x22, 0x33, 0x44}; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0); + + int32 expected = 0x11223344; + int32 observed = 0; + + int result = kmip_decode_int32_be(&ctx, &observed); + result = report_decoding_test_result( + tracker, + &ctx, + observed == expected, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_decode_int64_be(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[8] = { + 0x01, 0xB6, 0x9B, 0x4B, 0xA5, 0x74, 0x92, 0x00 + }; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0); + + int64 expected = 0x01B69B4BA5749200; + int64 observed = 0; + + int result = kmip_decode_int64_be(&ctx, &observed); + result = report_decoding_test_result( + tracker, + &ctx, + observed == expected, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_encode_integer(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 expected[16] = { + 0x42, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[16] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0); + + int result = kmip_encode_integer(&ctx, KMIP_TAG_DEFAULT, 8); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_decode_integer(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[16] = { + 0x42, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00 + }; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0); + + int32 expected = 8; + int32 observed = 0; + + int result = kmip_decode_integer(&ctx, KMIP_TAG_DEFAULT, &observed); + result = report_decoding_test_result( + tracker, + &ctx, + observed == expected, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_encode_long(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 expected[16] = { + 0x42, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x08, + 0x01, 0xB6, 0x9B, 0x4B, 0xA5, 0x74, 0x92, 0x00 + }; + + uint8 observed[16] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0); + + int result = kmip_encode_long(&ctx, KMIP_TAG_DEFAULT, 123456789000000000); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_decode_long(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[16] = { + 0x42, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x08, + 0x01, 0xB6, 0x9B, 0x4B, 0xA5, 0x74, 0x92, 0x00 + }; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0); + + int64 expected = 0x01B69B4BA5749200; + int64 observed = 0; + + int result = kmip_decode_long(&ctx, KMIP_TAG_DEFAULT, &observed); + result = report_decoding_test_result( + tracker, + &ctx, + observed == expected, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_encode_enum(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 expected[16] = { + 0x42, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[16] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0); + + int result = kmip_encode_enum(&ctx, KMIP_TAG_DEFAULT, KMIP_CRYPTOALG_AES); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_decode_enum(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[16] = { + 0x42, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00 + }; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0); + + enum cryptographic_algorithm expected = KMIP_CRYPTOALG_AES; + enum cryptographic_algorithm observed = 0; + + int result = kmip_decode_enum(&ctx, KMIP_TAG_DEFAULT, &observed); + result = report_decoding_test_result( + tracker, + &ctx, + observed == expected, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_encode_bool(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 expected[16] = { + 0x42, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x08, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 + }; + + uint8 observed[16] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0); + + int result = kmip_encode_bool(&ctx, KMIP_TAG_DEFAULT, KMIP_TRUE); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_decode_bool(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[16] = { + 0x42, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x08, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 + }; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0); + + bool32 expected = KMIP_TRUE; + bool32 observed = 0; + + int result = kmip_decode_bool(&ctx, KMIP_TAG_DEFAULT, &observed); + result = report_decoding_test_result( + tracker, + &ctx, + observed == expected, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_encode_text_string(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 expected[24] = { + 0x42, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x0B, + 0x48, 0x65, 0x6C, 0x6C, 0x6F, 0x20, 0x57, 0x6F, + 0x72, 0x6C, 0x64, 0x00, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[24] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0); + + struct text_string example = {0}; + example.value = "Hello World"; + example.size = 11; + + int result = kmip_encode_text_string(&ctx, KMIP_TAG_DEFAULT, &example); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_decode_text_string(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[24] = { + 0x42, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x0B, + 0x48, 0x65, 0x6C, 0x6C, 0x6F, 0x20, 0x57, 0x6F, + 0x72, 0x6C, 0x64, 0x00, 0x00, 0x00, 0x00, 0x00 + }; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0); + + struct text_string expected = {0}; + expected.value = "Hello World"; + expected.size = 11; + struct text_string observed = {0}; + + int result = kmip_decode_text_string(&ctx, KMIP_TAG_DEFAULT, &observed); + result = report_decoding_test_result( + tracker, + &ctx, + kmip_compare_text_string(&expected, &observed), + result, + __func__); + kmip_free_text_string(&ctx, &observed); + kmip_destroy(&ctx); + return(result); +} + +int +test_encode_byte_string(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 expected[16] = { + 0x42, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x03, + 0x01, 0x02, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[16] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0); + uint8 str[3] = {0x01, 0x02, 0x03}; + + struct byte_string example = {0}; + example.value = str; + example.size = 3; + + int result = kmip_encode_byte_string(&ctx, KMIP_TAG_DEFAULT, &example); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_decode_byte_string(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[16] = { + 0x42, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x03, + 0x01, 0x02, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00 + }; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0); + + uint8 str[3] = {0x01, 0x02, 0x03}; + + struct byte_string expected = {0}; + expected.value = str; + expected.size = 3; + struct byte_string observed = {0}; + + int result = kmip_decode_byte_string(&ctx, KMIP_TAG_DEFAULT, &observed); + result = report_decoding_test_result( + tracker, + &ctx, + kmip_compare_byte_string(&expected, &observed), + result, + __func__); + kmip_free_byte_string(&ctx, &observed); + kmip_destroy(&ctx); + return(result); +} + +int +test_encode_date_time(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 expected[16] = { + 0x42, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x08, + 0x00, 0x00, 0x00, 0x00, 0x47, 0xDA, 0x67, 0xF8 + }; + + uint8 observed[16] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0); + + int result = kmip_encode_date_time(&ctx, KMIP_TAG_DEFAULT, 1205495800); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_decode_date_time(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[16] = { + 0x42, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x08, + 0x00, 0x00, 0x00, 0x00, 0x47, 0xDA, 0x67, 0xF8 + }; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0); + + uint64 expected = 1205495800; + uint64 observed = 0; + + int result = kmip_decode_date_time(&ctx, KMIP_TAG_DEFAULT, &observed); + result = report_decoding_test_result( + tracker, + &ctx, + observed == expected, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_encode_interval(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 expected[16] = { + 0x42, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x0D, 0x2F, 0x00, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[16] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0); + + int result = kmip_encode_interval(&ctx, KMIP_TAG_DEFAULT, 864000); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_decode_interval(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[16] = { + 0x42, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x0D, 0x2F, 0x00, 0x00, 0x00, 0x00, 0x00 + }; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0); + + uint32 expected = 864000; + uint32 observed = 0; + + int result = kmip_decode_interval(&ctx, KMIP_TAG_DEFAULT, &observed); + result = report_decoding_test_result( + tracker, + &ctx, + observed == expected, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_encode_name(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 expected[48] = { + 0x42, 0x00, 0x53, 0x01, 0x00, 0x00, 0x00, 0x28, + 0x42, 0x00, 0x55, 0x07, 0x00, 0x00, 0x00, 0x09, + 0x54, 0x65, 0x6D, 0x70, 0x6C, 0x61, 0x74, 0x65, + 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x54, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[48] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0); + + struct text_string value = {0}; + value.value = "Template1"; + value.size = 9; + + struct name n = {0}; + n.value = &value; + n.type = KMIP_NAME_UNINTERPRETED_TEXT_STRING; + + int result = kmip_encode_name(&ctx, &n); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_decode_name(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[48] = { + 0x42, 0x00, 0x53, 0x01, 0x00, 0x00, 0x00, 0x28, + 0x42, 0x00, 0x55, 0x07, 0x00, 0x00, 0x00, 0x09, + 0x54, 0x65, 0x6D, 0x70, 0x6C, 0x61, 0x74, 0x65, + 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x54, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00 + }; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0); + + struct text_string value = {0}; + value.value = "Template1"; + value.size = 9; + + struct name expected = {0}; + expected.value = &value; + expected.type = KMIP_NAME_UNINTERPRETED_TEXT_STRING; + struct name observed = {0}; + + int result = kmip_decode_name(&ctx, &observed); + result = report_decoding_test_result( + tracker, + &ctx, + kmip_compare_name(&expected, &observed), + result, + __func__); + kmip_free_name(&ctx, &observed); + kmip_destroy(&ctx); + return(result); +} + +int +test_encode_protection_storage_masks(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + /* This encoding matches the following set of values: + * Protection Storage Masks + * Protection Storage Mask + * Software + * Hardware + * On Processor + * On System + * Off System + * Hypervisor + * Operating System + * Container + * On Premises + * Off Premises + * Self Managed + * Outsourced + * Validated + * Same Jurisdiction + * Protection Storage Mask + * Software + * Hardware + */ + uint8 expected[40] = { + 0x42, 0x01, 0x5F, 0x01, 0x00, 0x00, 0x00, 0x20, + 0x42, 0x01, 0x5E, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x3F, 0xFF, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x01, 0x5E, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[40] = {0}; + KMIP ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_2_0); + + LinkedList list = {0}; + LinkedListItem item_1 = {0}; + int32 mask_1 = 0x3FFF; + item_1.data = &mask_1; + + LinkedListItem item_2 = {0}; + int32 mask_2 = 0x0003; + item_2.data = &mask_2; + + kmip_linked_list_enqueue(&list, &item_1); + kmip_linked_list_enqueue(&list, &item_2); + + ProtectionStorageMasks psm = {0}; + psm.masks = &list; + + int result = kmip_encode_protection_storage_masks(&ctx, &psm); + result = report_encoding_test_result(tracker, &ctx, expected, observed, result, __func__); + + kmip_destroy(&ctx); + + return(result); +} + +int +test_decode_protection_storage_masks(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + /* This encoding matches the following set of values: + * Protection Storage Masks + * Protection Storage Mask + * Software + * Hardware + * On Processor + * On System + * Off System + * Hypervisor + * Operating System + * Container + * On Premises + * Off Premises + * Self Managed + * Outsourced + * Validated + * Same Jurisdiction + * Protection Storage Mask + * Software + * Hardware + */ + uint8 encoding[40] = { + 0x42, 0x01, 0x5F, 0x01, 0x00, 0x00, 0x00, 0x20, + 0x42, 0x01, 0x5E, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x3F, 0xFF, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x01, 0x5E, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00 + }; + + KMIP ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_2_0); + + LinkedList list = {0}; + LinkedListItem item_1 = {0}; + int32 mask_1 = 0x3FFF; + item_1.data = &mask_1; + + LinkedListItem item_2 = {0}; + int32 mask_2 = 0x0003; + item_2.data = &mask_2; + + kmip_linked_list_enqueue(&list, &item_1); + kmip_linked_list_enqueue(&list, &item_2); + + ProtectionStorageMasks expected = {0}; + expected.masks = &list; + + ProtectionStorageMasks observed = {0}; + int result = kmip_decode_protection_storage_masks(&ctx, &observed); + int comparison = kmip_compare_protection_storage_masks(&expected, &observed); + if(!comparison) + { + kmip_print_protection_storage_masks(1, &expected); + kmip_print_protection_storage_masks(1, &observed); + } + result = report_decoding_test_result(tracker, &ctx, comparison, result, __func__); + + kmip_free_protection_storage_masks(&ctx, &observed); + kmip_destroy(&ctx); + + return(result); +} + +int +test_encode_attribute_unique_identifier(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 expected[88] = { + 0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x50, + 0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x11, + 0x55, 0x6E, 0x69, 0x71, 0x75, 0x65, 0x20, 0x49, + 0x64, 0x65, 0x6E, 0x74, 0x69, 0x66, 0x69, 0x65, + 0x72, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x0B, 0x07, 0x00, 0x00, 0x00, 0x24, + 0x34, 0x39, 0x61, 0x31, 0x63, 0x61, 0x38, 0x38, + 0x2D, 0x36, 0x62, 0x65, 0x61, 0x2D, 0x34, 0x66, + 0x62, 0x32, 0x2D, 0x62, 0x34, 0x35, 0x30, 0x2D, + 0x37, 0x65, 0x35, 0x38, 0x38, 0x30, 0x32, 0x63, + 0x33, 0x30, 0x33, 0x38, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[88] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0); + + struct text_string uuid = {0}; + uuid.value = "49a1ca88-6bea-4fb2-b450-7e58802c3038"; + uuid.size = 36; + + struct attribute attr = {0}; + kmip_init_attribute(&attr); + + attr.type = KMIP_ATTR_UNIQUE_IDENTIFIER; + attr.value = &uuid; + + int result = kmip_encode_attribute(&ctx, &attr); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_decode_attribute_unique_identifier(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[88] = { + 0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x50, + 0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x11, + 0x55, 0x6E, 0x69, 0x71, 0x75, 0x65, 0x20, 0x49, + 0x64, 0x65, 0x6E, 0x74, 0x69, 0x66, 0x69, 0x65, + 0x72, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x0B, 0x07, 0x00, 0x00, 0x00, 0x24, + 0x34, 0x39, 0x61, 0x31, 0x63, 0x61, 0x38, 0x38, + 0x2D, 0x36, 0x62, 0x65, 0x61, 0x2D, 0x34, 0x66, + 0x62, 0x32, 0x2D, 0x62, 0x34, 0x35, 0x30, 0x2D, + 0x37, 0x65, 0x35, 0x38, 0x38, 0x30, 0x32, 0x63, + 0x33, 0x30, 0x33, 0x38, 0x00, 0x00, 0x00, 0x00 + }; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0); + + struct text_string uuid = {0}; + uuid.value = "49a1ca88-6bea-4fb2-b450-7e58802c3038"; + uuid.size = 36; + + struct attribute expected = {0}; + kmip_init_attribute(&expected); + expected.type = KMIP_ATTR_UNIQUE_IDENTIFIER; + expected.value = &uuid; + struct attribute observed = {0}; + kmip_init_attribute(&observed); + + int result = kmip_decode_attribute(&ctx, &observed); + result = report_decoding_test_result( + tracker, + &ctx, + kmip_compare_attribute(&expected, &observed), + result, + __func__); + kmip_free_attribute(&ctx, &observed); + kmip_destroy(&ctx); + return(result); +} + +int +test_encode_attribute_name(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 expected[72] = { + 0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x40, + 0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x04, + 0x4E, 0x61, 0x6D, 0x65, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x0B, 0x01, 0x00, 0x00, 0x00, 0x28, + 0x42, 0x00, 0x55, 0x07, 0x00, 0x00, 0x00, 0x09, + 0x54, 0x65, 0x6D, 0x70, 0x6C, 0x61, 0x74, 0x65, + 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x54, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[72] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0); + + struct text_string value = {0}; + value.value = "Template1"; + value.size = 9; + + struct name n = {0}; + n.value = &value; + n.type = KMIP_NAME_UNINTERPRETED_TEXT_STRING; + + struct attribute attr = {0}; + kmip_init_attribute(&attr); + + attr.type = KMIP_ATTR_NAME; + attr.value = &n; + + int result = kmip_encode_attribute(&ctx, &attr); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_decode_attribute_name(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[72] = { + 0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x40, + 0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x04, + 0x4E, 0x61, 0x6D, 0x65, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x0B, 0x01, 0x00, 0x00, 0x00, 0x28, + 0x42, 0x00, 0x55, 0x07, 0x00, 0x00, 0x00, 0x09, + 0x54, 0x65, 0x6D, 0x70, 0x6C, 0x61, 0x74, 0x65, + 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x54, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00 + }; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0); + + struct text_string value = {0}; + value.value = "Template1"; + value.size = 9; + + struct name n = {0}; + n.value = &value; + n.type = KMIP_NAME_UNINTERPRETED_TEXT_STRING; + + struct attribute expected = {0}; + kmip_init_attribute(&expected); + expected.type = KMIP_ATTR_NAME; + expected.value = &n; + struct attribute observed = {0}; + kmip_init_attribute(&observed); + + int result = kmip_decode_attribute(&ctx, &observed); + result = report_decoding_test_result( + tracker, + &ctx, + kmip_compare_attribute(&expected, &observed), + result, + __func__); + kmip_free_attribute(&ctx, &observed); + kmip_destroy(&ctx); + return(result); +} + +int +test_encode_attribute_object_type(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 expected[48] = { + 0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x28, + 0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x0B, + 0x4F, 0x62, 0x6A, 0x65, 0x63, 0x74, 0x20, 0x54, + 0x79, 0x70, 0x65, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x0B, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[48] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0); + + enum object_type t = KMIP_OBJTYPE_SYMMETRIC_KEY; + struct attribute attr = {0}; + kmip_init_attribute(&attr); + + attr.type = KMIP_ATTR_OBJECT_TYPE; + attr.value = &t; + + int result = kmip_encode_attribute(&ctx, &attr); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_decode_attribute_object_type(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[48] = { + 0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x28, + 0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x0B, + 0x4F, 0x62, 0x6A, 0x65, 0x63, 0x74, 0x20, 0x54, + 0x79, 0x70, 0x65, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x0B, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00 + }; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0); + + enum object_type t = KMIP_OBJTYPE_SYMMETRIC_KEY; + struct attribute expected = {0}; + kmip_init_attribute(&expected); + expected.type = KMIP_ATTR_OBJECT_TYPE; + expected.value = &t; + struct attribute observed = {0}; + kmip_init_attribute(&observed); + + int result = kmip_decode_attribute(&ctx, &observed); + result = report_decoding_test_result( + tracker, + &ctx, + kmip_compare_attribute(&expected, &observed), + result, + __func__); + kmip_free_attribute(&ctx, &observed); + kmip_destroy(&ctx); + return(result); +} + +int +test_encode_attribute_cryptographic_algorithm(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 expected[56] = { + 0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30, + 0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x17, + 0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, + 0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x41, 0x6C, + 0x67, 0x6F, 0x72, 0x69, 0x74, 0x68, 0x6D, 0x00, + 0x42, 0x00, 0x0B, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[56] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0); + + enum cryptographic_algorithm a = KMIP_CRYPTOALG_AES; + struct attribute attr = {0}; + kmip_init_attribute(&attr); + + attr.type = KMIP_ATTR_CRYPTOGRAPHIC_ALGORITHM; + attr.value = &a; + + int result = kmip_encode_attribute(&ctx, &attr); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_decode_attribute_cryptographic_algorithm(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[56] = { + 0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30, + 0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x17, + 0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, + 0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x41, 0x6C, + 0x67, 0x6F, 0x72, 0x69, 0x74, 0x68, 0x6D, 0x00, + 0x42, 0x00, 0x0B, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00 + }; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0); + + enum cryptographic_algorithm a = KMIP_CRYPTOALG_AES; + struct attribute expected = {0}; + kmip_init_attribute(&expected); + expected.type = KMIP_ATTR_CRYPTOGRAPHIC_ALGORITHM; + expected.value = &a; + struct attribute observed = {0}; + kmip_init_attribute(&observed); + + int result = kmip_decode_attribute(&ctx, &observed); + result = report_decoding_test_result( + tracker, + &ctx, + kmip_compare_attribute(&expected, &observed), + result, + __func__); + kmip_free_attribute(&ctx, &observed); + kmip_destroy(&ctx); + return(result); +} + +int +test_encode_attribute_cryptographic_length(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 expected[56] = { + 0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30, + 0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x14, + 0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, + 0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x4C, 0x65, + 0x6E, 0x67, 0x74, 0x68, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x0B, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[56] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0); + + int32 length = 128; + struct attribute attr = {0}; + kmip_init_attribute(&attr); + + attr.type = KMIP_ATTR_CRYPTOGRAPHIC_LENGTH; + attr.value = &length; + + int result = kmip_encode_attribute(&ctx, &attr); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_decode_attribute_cryptographic_length(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[56] = { + 0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30, + 0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x14, + 0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, + 0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x4C, 0x65, + 0x6E, 0x67, 0x74, 0x68, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x0B, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00 + }; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0); + + int32 length = 128; + struct attribute expected = {0}; + kmip_init_attribute(&expected); + expected.type = KMIP_ATTR_CRYPTOGRAPHIC_LENGTH; + expected.value = &length; + struct attribute observed = {0}; + kmip_init_attribute(&observed); + + int result = kmip_decode_attribute(&ctx, &observed); + result = report_decoding_test_result( + tracker, + &ctx, + kmip_compare_attribute(&expected, &observed), + result, + __func__); + kmip_free_attribute(&ctx, &observed); + kmip_destroy(&ctx); + return(result); +} + +int +test_encode_attribute_operation_policy_name(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 expected[56] = { + 0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30, + 0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x15, + 0x4F, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6F, + 0x6E, 0x20, 0x50, 0x6F, 0x6C, 0x69, 0x63, 0x79, + 0x20, 0x4E, 0x61, 0x6D, 0x65, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x0B, 0x07, 0x00, 0x00, 0x00, 0x07, + 0x64, 0x65, 0x66, 0x61, 0x75, 0x6C, 0x74, 0x00 + }; + + uint8 observed[56] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0); + + struct text_string policy = {0}; + policy.value = "default"; + policy.size = 7; + + struct attribute attr = {0}; + kmip_init_attribute(&attr); + + attr.type = KMIP_ATTR_OPERATION_POLICY_NAME; + attr.value = &policy; + + int result = kmip_encode_attribute(&ctx, &attr); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_decode_attribute_operation_policy_name(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[56] = { + 0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30, + 0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x15, + 0x4F, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6F, + 0x6E, 0x20, 0x50, 0x6F, 0x6C, 0x69, 0x63, 0x79, + 0x20, 0x4E, 0x61, 0x6D, 0x65, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x0B, 0x07, 0x00, 0x00, 0x00, 0x07, + 0x64, 0x65, 0x66, 0x61, 0x75, 0x6C, 0x74, 0x00 + }; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0); + + struct text_string policy = {0}; + policy.value = "default"; + policy.size = 7; + + struct attribute expected = {0}; + kmip_init_attribute(&expected); + expected.type = KMIP_ATTR_OPERATION_POLICY_NAME; + expected.value = &policy; + struct attribute observed = {0}; + kmip_init_attribute(&observed); + + int result = kmip_decode_attribute(&ctx, &observed); + result = report_decoding_test_result( + tracker, + &ctx, + kmip_compare_attribute(&expected, &observed), + result, + __func__); + kmip_free_attribute(&ctx, &observed); + kmip_destroy(&ctx); + return(result); +} + +int +test_encode_attribute_cryptographic_usage_mask(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 expected[56] = { + 0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30, + 0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x18, + 0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, + 0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x55, 0x73, + 0x61, 0x67, 0x65, 0x20, 0x4D, 0x61, 0x73, 0x6B, + 0x42, 0x00, 0x0B, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[56] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0); + + int32 mask = KMIP_CRYPTOMASK_ENCRYPT | KMIP_CRYPTOMASK_DECRYPT; + struct attribute attr = {0}; + kmip_init_attribute(&attr); + + attr.type = KMIP_ATTR_CRYPTOGRAPHIC_USAGE_MASK; + attr.value = &mask; + + int result = kmip_encode_attribute(&ctx, &attr); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_decode_attribute_cryptographic_usage_mask(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[56] = { + 0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30, + 0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x18, + 0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, + 0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x55, 0x73, + 0x61, 0x67, 0x65, 0x20, 0x4D, 0x61, 0x73, 0x6B, + 0x42, 0x00, 0x0B, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00 + }; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0); + + int32 mask = KMIP_CRYPTOMASK_ENCRYPT | KMIP_CRYPTOMASK_DECRYPT; + struct attribute expected = {0}; + kmip_init_attribute(&expected); + expected.type = KMIP_ATTR_CRYPTOGRAPHIC_USAGE_MASK; + expected.value = &mask; + struct attribute observed = {0}; + kmip_init_attribute(&observed); + + int result = kmip_decode_attribute(&ctx, &observed); + result = report_decoding_test_result( + tracker, + &ctx, + kmip_compare_attribute(&expected, &observed), + result, + __func__); + kmip_free_attribute(&ctx, &observed); + kmip_destroy(&ctx); + return(result); +} + +int +test_encode_attribute_state(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 expected[40] = { + 0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x20, + 0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x05, + 0x53, 0x74, 0x61, 0x74, 0x65, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x0B, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[40] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0); + + enum state s = KMIP_STATE_PRE_ACTIVE; + struct attribute attr = {0}; + kmip_init_attribute(&attr); + + attr.type = KMIP_ATTR_STATE; + attr.value = &s; + + int result = kmip_encode_attribute(&ctx, &attr); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_decode_attribute_state(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[40] = { + 0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x20, + 0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x05, + 0x53, 0x74, 0x61, 0x74, 0x65, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x0B, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00 + }; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0); + + enum state s = KMIP_STATE_PRE_ACTIVE; + struct attribute expected = {0}; + kmip_init_attribute(&expected); + expected.type = KMIP_ATTR_STATE; + expected.value = &s; + struct attribute observed = {0}; + kmip_init_attribute(&observed); + + int result = kmip_decode_attribute(&ctx, &observed); + result = report_decoding_test_result( + tracker, + &ctx, + kmip_compare_attribute(&expected, &observed), + result, + __func__); + kmip_free_attribute(&ctx, &observed); + kmip_destroy(&ctx); + return(result); +} + +int +test_encode_protocol_version(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 expected[40] = { + 0x42, 0x00, 0x69, 0x01, 0x00, 0x00, 0x00, 0x20, + 0x42, 0x00, 0x6A, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x6B, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[40] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0); + + struct protocol_version pv = {0}; + pv.major = 1; + pv.minor = 0; + + int result = kmip_encode_protocol_version(&ctx, &pv); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_decode_protocol_version(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[40] = { + 0x42, 0x00, 0x69, 0x01, 0x00, 0x00, 0x00, 0x20, + 0x42, 0x00, 0x6A, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x6B, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 + }; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0); + + struct protocol_version expected = {0}; + expected.major = 1; + expected.minor = 0; + struct protocol_version observed = {0}; + + int result = kmip_decode_protocol_version(&ctx, &observed); + result = report_decoding_test_result( + tracker, + &ctx, + kmip_compare_protocol_version(&expected, &observed), + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_encode_cryptographic_parameters(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 expected[72] = { + 0x42, 0x00, 0x2B, 0x01, 0x00, 0x00, 0x00, 0x40, + 0x42, 0x00, 0x11, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x5F, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x38, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x83, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[72] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0); + + struct cryptographic_parameters cp = {0}; + cp.block_cipher_mode = KMIP_BLOCK_CBC; + cp.padding_method = KMIP_PAD_PKCS5; + cp.hashing_algorithm = KMIP_HASH_SHA1; + cp.key_role_type = KMIP_ROLE_KEK; + + int result = kmip_encode_cryptographic_parameters(&ctx, &cp); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_decode_cryptographic_parameters(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[72] = { + 0x42, 0x00, 0x2B, 0x01, 0x00, 0x00, 0x00, 0x40, + 0x42, 0x00, 0x11, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x5F, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x38, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x83, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x00 + }; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0); + + struct cryptographic_parameters expected = {0}; + kmip_init_cryptographic_parameters(&expected); + expected.block_cipher_mode = KMIP_BLOCK_CBC; + expected.padding_method = KMIP_PAD_PKCS5; + expected.hashing_algorithm = KMIP_HASH_SHA1; + expected.key_role_type = KMIP_ROLE_KEK; + struct cryptographic_parameters observed = {0}; + kmip_init_cryptographic_parameters(&observed); + + int result = kmip_decode_cryptographic_parameters(&ctx, &observed); + result = report_decoding_test_result( + tracker, + &ctx, + kmip_compare_cryptographic_parameters(&expected, &observed), + result, + __func__); + kmip_free_cryptographic_parameters(&ctx, &observed); + kmip_destroy(&ctx); + return(result); +} + +int +test_encode_encryption_key_information(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 expected[80] = { + 0x42, 0x00, 0x36, 0x01, 0x00, 0x00, 0x00, 0x48, + 0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, + 0x31, 0x30, 0x30, 0x31, 0x38, 0x32, 0x64, 0x35, + 0x2D, 0x37, 0x32, 0x62, 0x38, 0x2D, 0x34, 0x37, + 0x61, 0x61, 0x2D, 0x38, 0x33, 0x38, 0x33, 0x2D, + 0x34, 0x64, 0x39, 0x37, 0x64, 0x35, 0x31, 0x32, + 0x65, 0x39, 0x38, 0x61, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x2B, 0x01, 0x00, 0x00, 0x00, 0x10, + 0x42, 0x00, 0x11, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[80] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0); + + struct text_string uuid = {0}; + uuid.value = "100182d5-72b8-47aa-8383-4d97d512e98a"; + uuid.size = 36; + + struct cryptographic_parameters cp = {0}; + cp.block_cipher_mode = KMIP_BLOCK_NIST_KEY_WRAP; + + struct encryption_key_information eki = {0}; + eki.unique_identifier = &uuid; + eki.cryptographic_parameters = &cp; + + int result = kmip_encode_encryption_key_information(&ctx, &eki); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_decode_encryption_key_information(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[80] = { + 0x42, 0x00, 0x36, 0x01, 0x00, 0x00, 0x00, 0x48, + 0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, + 0x31, 0x30, 0x30, 0x31, 0x38, 0x32, 0x64, 0x35, + 0x2D, 0x37, 0x32, 0x62, 0x38, 0x2D, 0x34, 0x37, + 0x61, 0x61, 0x2D, 0x38, 0x33, 0x38, 0x33, 0x2D, + 0x34, 0x64, 0x39, 0x37, 0x64, 0x35, 0x31, 0x32, + 0x65, 0x39, 0x38, 0x61, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x2B, 0x01, 0x00, 0x00, 0x00, 0x10, + 0x42, 0x00, 0x11, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x00 + }; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0); + + struct text_string uuid = {0}; + uuid.value = "100182d5-72b8-47aa-8383-4d97d512e98a"; + uuid.size = 36; + + struct cryptographic_parameters cp = {0}; + kmip_init_cryptographic_parameters(&cp); + + cp.block_cipher_mode = KMIP_BLOCK_NIST_KEY_WRAP; + + struct encryption_key_information expected = {0}; + expected.unique_identifier = &uuid; + expected.cryptographic_parameters = &cp; + + struct encryption_key_information observed = {0}; + + int result = kmip_decode_encryption_key_information(&ctx, &observed); + result = report_decoding_test_result( + tracker, + &ctx, + kmip_compare_encryption_key_information(&expected, &observed), + result, + __func__); + kmip_free_encryption_key_information(&ctx, &observed); + kmip_destroy(&ctx); + return(result); +} + +int +test_encode_mac_signature_key_information(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 expected[80] = { + 0x42, 0x00, 0x4E, 0x01, 0x00, 0x00, 0x00, 0x48, + 0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, + 0x31, 0x30, 0x30, 0x31, 0x38, 0x32, 0x64, 0x35, + 0x2D, 0x37, 0x32, 0x62, 0x38, 0x2D, 0x34, 0x37, + 0x61, 0x61, 0x2D, 0x38, 0x33, 0x38, 0x33, 0x2D, + 0x34, 0x64, 0x39, 0x37, 0x64, 0x35, 0x31, 0x32, + 0x65, 0x39, 0x38, 0x61, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x2B, 0x01, 0x00, 0x00, 0x00, 0x10, + 0x42, 0x00, 0x11, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[80] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0); + + struct text_string uuid = {0}; + uuid.value = "100182d5-72b8-47aa-8383-4d97d512e98a"; + uuid.size = 36; + + struct cryptographic_parameters cp = {0}; + cp.block_cipher_mode = KMIP_BLOCK_NIST_KEY_WRAP; + + struct mac_signature_key_information mski = {0}; + mski.unique_identifier = &uuid; + mski.cryptographic_parameters = &cp; + + int result = kmip_encode_mac_signature_key_information(&ctx, &mski); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_decode_mac_signature_key_information(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[80] = { + 0x42, 0x00, 0x4E, 0x01, 0x00, 0x00, 0x00, 0x48, + 0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, + 0x31, 0x30, 0x30, 0x31, 0x38, 0x32, 0x64, 0x35, + 0x2D, 0x37, 0x32, 0x62, 0x38, 0x2D, 0x34, 0x37, + 0x61, 0x61, 0x2D, 0x38, 0x33, 0x38, 0x33, 0x2D, + 0x34, 0x64, 0x39, 0x37, 0x64, 0x35, 0x31, 0x32, + 0x65, 0x39, 0x38, 0x61, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x2B, 0x01, 0x00, 0x00, 0x00, 0x10, + 0x42, 0x00, 0x11, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x00 + }; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0); + + struct text_string uuid = {0}; + uuid.value = "100182d5-72b8-47aa-8383-4d97d512e98a"; + uuid.size = 36; + + struct cryptographic_parameters cp = {0}; + kmip_init_cryptographic_parameters(&cp); + + cp.block_cipher_mode = KMIP_BLOCK_NIST_KEY_WRAP; + + struct mac_signature_key_information expected = {0}; + expected.unique_identifier = &uuid; + expected.cryptographic_parameters = &cp; + + struct mac_signature_key_information observed = {0}; + + int result = kmip_decode_mac_signature_key_information(&ctx, &observed); + result = report_decoding_test_result( + tracker, + &ctx, + kmip_compare_mac_signature_key_information(&expected, &observed), + result, + __func__); + kmip_free_mac_signature_key_information(&ctx, &observed); + kmip_destroy(&ctx); + return(result); +} + +int +test_encode_key_wrapping_data(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 expected[104] = { + 0x42, 0x00, 0x46, 0x01, 0x00, 0x00, 0x00, 0x60, + 0x42, 0x00, 0x9E, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x36, 0x01, 0x00, 0x00, 0x00, 0x48, + 0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, + 0x31, 0x30, 0x30, 0x31, 0x38, 0x32, 0x64, 0x35, + 0x2D, 0x37, 0x32, 0x62, 0x38, 0x2D, 0x34, 0x37, + 0x61, 0x61, 0x2D, 0x38, 0x33, 0x38, 0x33, 0x2D, + 0x34, 0x64, 0x39, 0x37, 0x64, 0x35, 0x31, 0x32, + 0x65, 0x39, 0x38, 0x61, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x2B, 0x01, 0x00, 0x00, 0x00, 0x10, + 0x42, 0x00, 0x11, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[104] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0); + + struct text_string uuid = {0}; + uuid.value = "100182d5-72b8-47aa-8383-4d97d512e98a"; + uuid.size = 36; + + struct cryptographic_parameters cp = {0}; + cp.block_cipher_mode = KMIP_BLOCK_NIST_KEY_WRAP; + + struct encryption_key_information eki = {0}; + eki.unique_identifier = &uuid; + eki.cryptographic_parameters = &cp; + + struct key_wrapping_data kwd = {0}; + kwd.wrapping_method = KMIP_WRAP_ENCRYPT; + kwd.encryption_key_info = &eki; + + int result = kmip_encode_key_wrapping_data(&ctx, &kwd); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_decode_key_wrapping_data(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[104] = { + 0x42, 0x00, 0x46, 0x01, 0x00, 0x00, 0x00, 0x60, + 0x42, 0x00, 0x9E, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x36, 0x01, 0x00, 0x00, 0x00, 0x48, + 0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, + 0x31, 0x30, 0x30, 0x31, 0x38, 0x32, 0x64, 0x35, + 0x2D, 0x37, 0x32, 0x62, 0x38, 0x2D, 0x34, 0x37, + 0x61, 0x61, 0x2D, 0x38, 0x33, 0x38, 0x33, 0x2D, + 0x34, 0x64, 0x39, 0x37, 0x64, 0x35, 0x31, 0x32, + 0x65, 0x39, 0x38, 0x61, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x2B, 0x01, 0x00, 0x00, 0x00, 0x10, + 0x42, 0x00, 0x11, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x00 + }; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0); + + struct text_string uuid = {0}; + uuid.value = "100182d5-72b8-47aa-8383-4d97d512e98a"; + uuid.size = 36; + + struct cryptographic_parameters cp = {0}; + kmip_init_cryptographic_parameters(&cp); + + cp.block_cipher_mode = KMIP_BLOCK_NIST_KEY_WRAP; + + struct encryption_key_information eki = {0}; + eki.unique_identifier = &uuid; + eki.cryptographic_parameters = &cp; + + struct key_wrapping_data expected = {0}; + expected.wrapping_method = KMIP_WRAP_ENCRYPT; + expected.encryption_key_info = &eki; + + struct key_wrapping_data observed = {0}; + + int result = kmip_decode_key_wrapping_data(&ctx, &observed); + result = report_decoding_test_result( + tracker, + &ctx, + kmip_compare_key_wrapping_data(&expected, &observed), + result, + __func__); + kmip_free_key_wrapping_data(&ctx, &observed); + kmip_destroy(&ctx); + return(result); +} + +int +test_encode_key_material_byte_string(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 expected[24] = { + 0x42, 0x00, 0x43, 0x08, 0x00, 0x00, 0x00, 0x10, + 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, + 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF + }; + + uint8 observed[24] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0); + + uint8 value[16] = { + 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, + 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF + }; + struct byte_string key = {0}; + key.value = value; + key.size = ARRAY_LENGTH(value); + + int result = kmip_encode_key_material(&ctx, KMIP_KEYFORMAT_RAW, &key); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_decode_key_material_byte_string(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[24] = { + 0x42, 0x00, 0x43, 0x08, 0x00, 0x00, 0x00, 0x10, + 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, + 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF + }; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0); + + uint8 value[16] = { + 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, + 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF + }; + struct byte_string expected = {0}; + expected.value = value; + expected.size = ARRAY_LENGTH(value); + + struct byte_string *expected_ptr = &expected; + struct byte_string *observed_ptr = NULL; + + int result = kmip_decode_key_material( + &ctx, + KMIP_KEYFORMAT_RAW, + (void**)&observed_ptr); + result = report_decoding_test_result( + tracker, + &ctx, + kmip_compare_key_material(KMIP_KEYFORMAT_RAW, (void**)&expected_ptr, (void**)&observed_ptr), + result, + __func__); + kmip_free_key_material(&ctx, KMIP_KEYFORMAT_RAW, (void**)&observed_ptr); + kmip_destroy(&ctx); + return(result); +} + +int +test_encode_key_material_transparent_symmetric_key(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 expected[48] = { + 0x42, 0x00, 0x43, 0x01, 0x00, 0x00, 0x00, 0x28, + 0x42, 0x00, 0x3F, 0x08, 0x00, 0x00, 0x00, 0x20, + 0x00, 0x00, 0x11, 0x11, 0x22, 0x22, 0x33, 0x33, + 0x44, 0x44, 0x55, 0x55, 0x66, 0x66, 0x77, 0x77, + 0x88, 0x88, 0x99, 0x99, 0xAA, 0xAA, 0xBB, 0xBB, + 0xCC, 0xCC, 0xDD, 0xDD, 0xEE, 0xEE, 0xFF, 0xFF + }; + + uint8 observed[48] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0); + + uint8 value[32] = { + 0x00, 0x00, 0x11, 0x11, 0x22, 0x22, 0x33, 0x33, + 0x44, 0x44, 0x55, 0x55, 0x66, 0x66, 0x77, 0x77, + 0x88, 0x88, 0x99, 0x99, 0xAA, 0xAA, 0xBB, 0xBB, + 0xCC, 0xCC, 0xDD, 0xDD, 0xEE, 0xEE, 0xFF, 0xFF + }; + struct byte_string key = {0}; + key.value = value; + key.size = ARRAY_LENGTH(value); + struct transparent_symmetric_key tsk = {0}; + tsk.key = &key; + + int result = kmip_encode_key_material(&ctx, KMIP_KEYFORMAT_TRANS_SYMMETRIC_KEY, &tsk); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_decode_key_material_transparent_symmetric_key(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[48] = { + 0x42, 0x00, 0x43, 0x01, 0x00, 0x00, 0x00, 0x28, + 0x42, 0x00, 0x3F, 0x08, 0x00, 0x00, 0x00, 0x20, + 0x00, 0x00, 0x11, 0x11, 0x22, 0x22, 0x33, 0x33, + 0x44, 0x44, 0x55, 0x55, 0x66, 0x66, 0x77, 0x77, + 0x88, 0x88, 0x99, 0x99, 0xAA, 0xAA, 0xBB, 0xBB, + 0xCC, 0xCC, 0xDD, 0xDD, 0xEE, 0xEE, 0xFF, 0xFF + }; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0); + + uint8 value[32] = { + 0x00, 0x00, 0x11, 0x11, 0x22, 0x22, 0x33, 0x33, + 0x44, 0x44, 0x55, 0x55, 0x66, 0x66, 0x77, 0x77, + 0x88, 0x88, 0x99, 0x99, 0xAA, 0xAA, 0xBB, 0xBB, + 0xCC, 0xCC, 0xDD, 0xDD, 0xEE, 0xEE, 0xFF, 0xFF + }; + struct byte_string key = {0}; + key.value = value; + key.size = ARRAY_LENGTH(value); + struct transparent_symmetric_key expected = {0}; + expected.key = &key; + + struct transparent_symmetric_key *expected_ptr = &expected; + struct transparent_symmetric_key *observed_ptr = NULL; + + int result = kmip_decode_key_material( + &ctx, + KMIP_KEYFORMAT_TRANS_SYMMETRIC_KEY, + (void**)&observed_ptr); + result = report_decoding_test_result( + tracker, + &ctx, + kmip_compare_key_material(KMIP_KEYFORMAT_TRANS_SYMMETRIC_KEY, (void**)&expected_ptr, (void**)&observed_ptr), + result, + __func__); + kmip_free_key_material( + &ctx, + KMIP_KEYFORMAT_TRANS_SYMMETRIC_KEY, + (void**)&observed_ptr); + kmip_destroy(&ctx); + return(result); +} + +int +test_encode_key_value(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 expected[32] = { + 0x42, 0x00, 0x45, 0x01, 0x00, 0x00, 0x00, 0x18, + 0x42, 0x00, 0x43, 0x08, 0x00, 0x00, 0x00, 0x10, + 0xD3, 0x51, 0x91, 0x0F, 0x1D, 0x79, 0x34, 0xD6, + 0xE2, 0xAE, 0x17, 0x57, 0x65, 0x64, 0xE2, 0xBC + }; + + uint8 observed[32] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0); + + uint8 value[16] = { + 0xD3, 0x51, 0x91, 0x0F, 0x1D, 0x79, 0x34, 0xD6, + 0xE2, 0xAE, 0x17, 0x57, 0x65, 0x64, 0xE2, 0xBC + }; + struct byte_string key = {0}; + key.value = value; + key.size = ARRAY_LENGTH(value); + + struct key_value kv = {0}; + kv.key_material = &key; + + int result = kmip_encode_key_value(&ctx, KMIP_KEYFORMAT_RAW, &kv); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_decode_key_value(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[32] = { + 0x42, 0x00, 0x45, 0x01, 0x00, 0x00, 0x00, 0x18, + 0x42, 0x00, 0x43, 0x08, 0x00, 0x00, 0x00, 0x10, + 0xD3, 0x51, 0x91, 0x0F, 0x1D, 0x79, 0x34, 0xD6, + 0xE2, 0xAE, 0x17, 0x57, 0x65, 0x64, 0xE2, 0xBC + }; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0); + + uint8 value[16] = { + 0xD3, 0x51, 0x91, 0x0F, 0x1D, 0x79, 0x34, 0xD6, + 0xE2, 0xAE, 0x17, 0x57, 0x65, 0x64, 0xE2, 0xBC + }; + struct byte_string key = {0}; + key.value = value; + key.size = ARRAY_LENGTH(value); + + struct key_value expected = {0}; + expected.key_material = &key; + struct key_value observed = {0}; + + int result = kmip_decode_key_value(&ctx, KMIP_KEYFORMAT_RAW, &observed); + result = report_decoding_test_result( + tracker, + &ctx, + kmip_compare_key_value(KMIP_KEYFORMAT_RAW, &expected, &observed), + result, + __func__); + kmip_free_key_value(&ctx, KMIP_KEYFORMAT_RAW, &observed); + kmip_destroy(&ctx); + return(result); +} + +int +test_encode_key_value_with_attributes(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 expected[144] = { + 0x42, 0x00, 0x45, 0x01, 0x00, 0x00, 0x00, 0x88, + 0x42, 0x00, 0x43, 0x08, 0x00, 0x00, 0x00, 0x10, + 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, + 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF, + 0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30, + 0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x17, + 0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, + 0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x41, 0x6C, + 0x67, 0x6F, 0x72, 0x69, 0x74, 0x68, 0x6D, 0x00, + 0x42, 0x00, 0x0B, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30, + 0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x14, + 0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, + 0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x4C, 0x65, + 0x6E, 0x67, 0x74, 0x68, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x0B, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[144] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0); + + uint8 value[16] = { + 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, + 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF + }; + struct byte_string key = {0}; + key.value = value; + key.size = ARRAY_LENGTH(value); + + struct attribute attributes[2] = {0}; + for(int i = 0; i < 2; i++) + { + kmip_init_attribute(&attributes[i]); + } + + enum cryptographic_algorithm ca = KMIP_CRYPTOALG_AES; + int length = 128; + attributes[0].type = KMIP_ATTR_CRYPTOGRAPHIC_ALGORITHM; + attributes[0].value = &ca; + attributes[1].type = KMIP_ATTR_CRYPTOGRAPHIC_LENGTH; + attributes[1].value = &length; + + struct key_value kv = {0}; + kv.key_material = &key; + kv.attributes = attributes; + kv.attribute_count = ARRAY_LENGTH(attributes); + + int result = kmip_encode_key_value(&ctx, KMIP_KEYFORMAT_RAW, &kv); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_decode_key_value_with_attributes(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[144] = { + 0x42, 0x00, 0x45, 0x01, 0x00, 0x00, 0x00, 0x88, + 0x42, 0x00, 0x43, 0x08, 0x00, 0x00, 0x00, 0x10, + 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, + 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF, + 0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30, + 0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x17, + 0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, + 0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x41, 0x6C, + 0x67, 0x6F, 0x72, 0x69, 0x74, 0x68, 0x6D, 0x00, + 0x42, 0x00, 0x0B, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30, + 0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x14, + 0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, + 0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x4C, 0x65, + 0x6E, 0x67, 0x74, 0x68, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x0B, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00 + }; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0); + + uint8 value[16] = { + 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, + 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF + }; + struct byte_string key = {0}; + key.value = value; + key.size = ARRAY_LENGTH(value); + + struct attribute attributes[2] = {0}; + for(size_t i = 0; i < 2; i++) + { + kmip_init_attribute(&attributes[i]); + } + + enum cryptographic_algorithm ca = KMIP_CRYPTOALG_AES; + int length = 128; + attributes[0].type = KMIP_ATTR_CRYPTOGRAPHIC_ALGORITHM; + attributes[0].value = &ca; + attributes[1].type = KMIP_ATTR_CRYPTOGRAPHIC_LENGTH; + attributes[1].value = &length; + + struct key_value expected = {0}; + expected.key_material = &key; + expected.attributes = attributes; + expected.attribute_count = ARRAY_LENGTH(attributes); + struct key_value observed = {0}; + + int result = kmip_decode_key_value(&ctx, KMIP_KEYFORMAT_RAW, &observed); + result = report_decoding_test_result( + tracker, + &ctx, + kmip_compare_key_value(KMIP_KEYFORMAT_RAW, &expected, &observed), + result, + __func__); + kmip_free_key_value(&ctx, KMIP_KEYFORMAT_RAW, &observed); + kmip_destroy(&ctx); + return(result); +} + +int +test_encode_key_block_key_value_byte_string(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 expected[192] = { + 0x42, 0x00, 0x40, 0x01, 0x00, 0x00, 0x00, 0xB8, + 0x42, 0x00, 0x42, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x45, 0x08, 0x00, 0x00, 0x00, 0x18, + 0x1F, 0xA6, 0x8B, 0x0A, 0x81, 0x12, 0xB4, 0x47, + 0xAE, 0xF3, 0x4B, 0xD8, 0xFB, 0x5A, 0x7B, 0x82, + 0x9D, 0x3E, 0x86, 0x23, 0x71, 0xD2, 0xCF, 0xE5, + 0x42, 0x00, 0x28, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x2A, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x46, 0x01, 0x00, 0x00, 0x00, 0x60, + 0x42, 0x00, 0x9E, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x36, 0x01, 0x00, 0x00, 0x00, 0x48, + 0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, + 0x31, 0x30, 0x30, 0x31, 0x38, 0x32, 0x64, 0x35, + 0x2D, 0x37, 0x32, 0x62, 0x38, 0x2D, 0x34, 0x37, + 0x61, 0x61, 0x2D, 0x38, 0x33, 0x38, 0x33, 0x2D, + 0x34, 0x64, 0x39, 0x37, 0x64, 0x35, 0x31, 0x32, + 0x65, 0x39, 0x38, 0x61, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x2B, 0x01, 0x00, 0x00, 0x00, 0x10, + 0x42, 0x00, 0x11, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[192] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0); + + uint8 value[24] = { + 0x1F, 0xA6, 0x8B, 0x0A, 0x81, 0x12, 0xB4, 0x47, + 0xAE, 0xF3, 0x4B, 0xD8, 0xFB, 0x5A, 0x7B, 0x82, + 0x9D, 0x3E, 0x86, 0x23, 0x71, 0xD2, 0xCF, 0xE5 + }; + struct byte_string key = {0}; + key.value = value; + key.size = ARRAY_LENGTH(value); + + struct text_string uuid = {0}; + uuid.value = "100182d5-72b8-47aa-8383-4d97d512e98a"; + uuid.size = 36; + + struct cryptographic_parameters cp = {0}; + cp.block_cipher_mode = KMIP_BLOCK_NIST_KEY_WRAP; + + struct encryption_key_information eki = {0}; + eki.unique_identifier = &uuid; + eki.cryptographic_parameters = &cp; + + struct key_wrapping_data kwd = {0}; + kwd.wrapping_method = KMIP_WRAP_ENCRYPT; + kwd.encryption_key_info = &eki; + + struct key_block kb = {0}; + kb.key_format_type = KMIP_KEYFORMAT_RAW; + kb.key_value = &key; + kb.cryptographic_algorithm = KMIP_CRYPTOALG_AES; + kb.cryptographic_length = 128; + kb.key_wrapping_data = &kwd; + + int result = kmip_encode_key_block(&ctx, &kb); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_decode_key_block_key_value_byte_string(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[192] = { + 0x42, 0x00, 0x40, 0x01, 0x00, 0x00, 0x00, 0xB8, + 0x42, 0x00, 0x42, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x45, 0x08, 0x00, 0x00, 0x00, 0x18, + 0x1F, 0xA6, 0x8B, 0x0A, 0x81, 0x12, 0xB4, 0x47, + 0xAE, 0xF3, 0x4B, 0xD8, 0xFB, 0x5A, 0x7B, 0x82, + 0x9D, 0x3E, 0x86, 0x23, 0x71, 0xD2, 0xCF, 0xE5, + 0x42, 0x00, 0x28, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x2A, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x46, 0x01, 0x00, 0x00, 0x00, 0x60, + 0x42, 0x00, 0x9E, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x36, 0x01, 0x00, 0x00, 0x00, 0x48, + 0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, + 0x31, 0x30, 0x30, 0x31, 0x38, 0x32, 0x64, 0x35, + 0x2D, 0x37, 0x32, 0x62, 0x38, 0x2D, 0x34, 0x37, + 0x61, 0x61, 0x2D, 0x38, 0x33, 0x38, 0x33, 0x2D, + 0x34, 0x64, 0x39, 0x37, 0x64, 0x35, 0x31, 0x32, + 0x65, 0x39, 0x38, 0x61, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x2B, 0x01, 0x00, 0x00, 0x00, 0x10, + 0x42, 0x00, 0x11, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x00 + }; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0); + + uint8 value[24] = { + 0x1F, 0xA6, 0x8B, 0x0A, 0x81, 0x12, 0xB4, 0x47, + 0xAE, 0xF3, 0x4B, 0xD8, 0xFB, 0x5A, 0x7B, 0x82, + 0x9D, 0x3E, 0x86, 0x23, 0x71, 0xD2, 0xCF, 0xE5 + }; + struct byte_string key = {0}; + key.value = value; + key.size = ARRAY_LENGTH(value); + + struct text_string uuid = {0}; + uuid.value = "100182d5-72b8-47aa-8383-4d97d512e98a"; + uuid.size = 36; + + struct cryptographic_parameters cp = {0}; + kmip_init_cryptographic_parameters(&cp); + + cp.block_cipher_mode = KMIP_BLOCK_NIST_KEY_WRAP; + + struct encryption_key_information eki = {0}; + eki.unique_identifier = &uuid; + eki.cryptographic_parameters = &cp; + + struct key_wrapping_data kwd = {0}; + kwd.wrapping_method = KMIP_WRAP_ENCRYPT; + kwd.encryption_key_info = &eki; + + struct key_block expected = {0}; + kmip_init_key_block(&expected); + + expected.key_format_type = KMIP_KEYFORMAT_RAW; + expected.key_value = &key; + expected.key_value_type = KMIP_TYPE_BYTE_STRING; + expected.cryptographic_algorithm = KMIP_CRYPTOALG_AES; + expected.cryptographic_length = 128; + expected.key_wrapping_data = &kwd; + + struct key_block observed = {0}; + kmip_init_key_block(&observed); + + int result = kmip_decode_key_block(&ctx, &observed); + result = report_decoding_test_result( + tracker, + &ctx, + kmip_compare_key_block(&expected, &observed), + result, + __func__); + kmip_free_key_block(&ctx, &observed); + kmip_destroy(&ctx); + return(result); +} + +int +test_encode_key_block_key_value_structure(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 expected[88] = { + 0x42, 0x00, 0x40, 0x01, 0x00, 0x00, 0x00, 0x50, + 0x42, 0x00, 0x42, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x45, 0x01, 0x00, 0x00, 0x00, 0x18, + 0x42, 0x00, 0x43, 0x08, 0x00, 0x00, 0x00, 0x10, + 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, + 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF, + 0x42, 0x00, 0x28, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x2A, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[88] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0); + + uint8 value[16] = { + 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, + 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF + }; + struct byte_string key = {0}; + key.value = value; + key.size = ARRAY_LENGTH(value); + + struct key_value kv = {0}; + kv.key_material = &key; + + struct key_block kb = {0}; + kb.key_format_type = KMIP_KEYFORMAT_RAW; + kb.key_value = &kv; + kb.cryptographic_algorithm = KMIP_CRYPTOALG_AES; + kb.cryptographic_length = 128; + + int result = kmip_encode_key_block(&ctx, &kb); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_decode_key_block_key_value_structure(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[88] = { + 0x42, 0x00, 0x40, 0x01, 0x00, 0x00, 0x00, 0x50, + 0x42, 0x00, 0x42, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x45, 0x01, 0x00, 0x00, 0x00, 0x18, + 0x42, 0x00, 0x43, 0x08, 0x00, 0x00, 0x00, 0x10, + 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, + 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF, + 0x42, 0x00, 0x28, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x2A, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00 + }; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0); + + uint8 value[16] = { + 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, + 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF + }; + struct byte_string key = {0}; + key.value = value; + key.size = ARRAY_LENGTH(value); + + struct key_value kv = {0}; + kv.key_material = &key; + + struct key_block expected = {0}; + kmip_init_key_block(&expected); + + expected.key_format_type = KMIP_KEYFORMAT_RAW; + expected.key_value = &kv; + expected.key_value_type = KMIP_TYPE_STRUCTURE; + expected.cryptographic_algorithm = KMIP_CRYPTOALG_AES; + expected.cryptographic_length = 128; + + struct key_block observed = {0}; + kmip_init_key_block(&observed); + + int result = kmip_decode_key_block(&ctx, &observed); + result = report_decoding_test_result( + tracker, + &ctx, + kmip_compare_key_block(&expected, &observed), + result, + __func__); + kmip_free_key_block(&ctx, &observed); + kmip_destroy(&ctx); + return(result); +} + +int +test_encode_symmetric_key(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 expected[96] = { + 0x42, 0x00, 0x8F, 0x01, 0x00, 0x00, 0x00, 0x58, + 0x42, 0x00, 0x40, 0x01, 0x00, 0x00, 0x00, 0x50, + 0x42, 0x00, 0x42, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x45, 0x01, 0x00, 0x00, 0x00, 0x18, + 0x42, 0x00, 0x43, 0x08, 0x00, 0x00, 0x00, 0x10, + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, + 0x42, 0x00, 0x28, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x2A, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[96] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0); + + uint8 value[16] = { + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F + }; + struct byte_string key = {0}; + key.value = value; + key.size = ARRAY_LENGTH(value); + + struct key_value kv = {0}; + kv.key_material = &key; + + struct key_block kb = {0}; + kb.key_format_type = KMIP_KEYFORMAT_RAW; + kb.key_value = &kv; + kb.cryptographic_algorithm = KMIP_CRYPTOALG_AES; + kb.cryptographic_length = 128; + + struct symmetric_key sk = {0}; + sk.key_block = &kb; + + int result = kmip_encode_symmetric_key(&ctx, &sk); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_decode_symmetric_key(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[96] = { + 0x42, 0x00, 0x8F, 0x01, 0x00, 0x00, 0x00, 0x58, + 0x42, 0x00, 0x40, 0x01, 0x00, 0x00, 0x00, 0x50, + 0x42, 0x00, 0x42, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x45, 0x01, 0x00, 0x00, 0x00, 0x18, + 0x42, 0x00, 0x43, 0x08, 0x00, 0x00, 0x00, 0x10, + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, + 0x42, 0x00, 0x28, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x2A, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00 + }; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0); + + uint8 value[16] = { + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F + }; + struct byte_string key = {0}; + key.value = value; + key.size = ARRAY_LENGTH(value); + + struct key_value kv = {0}; + kv.key_material = &key; + + struct key_block kb = {0}; + kb.key_format_type = KMIP_KEYFORMAT_RAW; + kb.key_value = &kv; + kb.key_value_type = KMIP_TYPE_STRUCTURE; + kb.cryptographic_algorithm = KMIP_CRYPTOALG_AES; + kb.cryptographic_length = 128; + + struct symmetric_key expected = {0}; + expected.key_block = &kb; + + struct symmetric_key observed = {0}; + + int result = kmip_decode_symmetric_key(&ctx, &observed); + result = report_decoding_test_result( + tracker, + &ctx, + kmip_compare_symmetric_key(&expected, &observed), + result, + __func__); + kmip_free_symmetric_key(&ctx, &observed); + kmip_destroy(&ctx); + return(result); +} + +int +test_encode_public_key(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 expected[248] = { + 0x42, 0x00, 0x6D, 0x01, 0x00, 0x00, 0x00, 0xF0, + 0x42, 0x00, 0x40, 0x01, 0x00, 0x00, 0x00, 0xE8, + 0x42, 0x00, 0x42, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x45, 0x01, 0x00, 0x00, 0x00, 0xB0, + 0x42, 0x00, 0x43, 0x08, 0x00, 0x00, 0x00, 0xA2, + 0x30, 0x81, 0x9F, 0x30, 0x0D, 0x06, 0x09, 0x2A, + 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x01, + 0x05, 0x00, 0x03, 0x81, 0x8D, 0x00, 0x30, 0x81, + 0x89, 0x02, 0x81, 0x81, 0x00, 0x93, 0x04, 0x51, + 0xC9, 0xEC, 0xD9, 0x4F, 0x5B, 0xB9, 0xDA, 0x17, + 0xDD, 0x09, 0x38, 0x1B, 0xD2, 0x3B, 0xE4, 0x3E, + 0xCA, 0x8C, 0x75, 0x39, 0xF3, 0x01, 0xFC, 0x8A, + 0x8C, 0xD5, 0xD5, 0x27, 0x4C, 0x3E, 0x76, 0x99, + 0xDB, 0xDC, 0x71, 0x1C, 0x97, 0xA7, 0xAA, 0x91, + 0xE2, 0xC5, 0x0A, 0x82, 0xBD, 0x0B, 0x10, 0x34, + 0xF0, 0xDF, 0x49, 0x3D, 0xEC, 0x16, 0x36, 0x24, + 0x27, 0xE5, 0x8A, 0xCC, 0xE7, 0xF6, 0xCE, 0x0F, + 0x9B, 0xCC, 0x61, 0x7B, 0xBD, 0x8C, 0x90, 0xD0, + 0x09, 0x4A, 0x27, 0x03, 0xBA, 0x0D, 0x09, 0xEB, + 0x19, 0xD1, 0x00, 0x5F, 0x2F, 0xB2, 0x65, 0x52, + 0x6A, 0xAC, 0x75, 0xAF, 0x32, 0xF8, 0xBC, 0x78, + 0x2C, 0xDE, 0xD2, 0xA5, 0x7F, 0x81, 0x1E, 0x03, + 0xEA, 0xF6, 0x7A, 0x94, 0x4D, 0xE5, 0xE7, 0x84, + 0x13, 0xDC, 0xA8, 0xF2, 0x32, 0xD0, 0x74, 0xE6, + 0xDC, 0xEA, 0x4C, 0xEC, 0x9F, 0x02, 0x03, 0x01, + 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x28, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x2A, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[248] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0); + + uint8 value[162] = { + 0x30, 0x81, 0x9F, 0x30, 0x0D, 0x06, 0x09, 0x2A, + 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x01, + 0x05, 0x00, 0x03, 0x81, 0x8D, 0x00, 0x30, 0x81, + 0x89, 0x02, 0x81, 0x81, 0x00, 0x93, 0x04, 0x51, + 0xC9, 0xEC, 0xD9, 0x4F, 0x5B, 0xB9, 0xDA, 0x17, + 0xDD, 0x09, 0x38, 0x1B, 0xD2, 0x3B, 0xE4, 0x3E, + 0xCA, 0x8C, 0x75, 0x39, 0xF3, 0x01, 0xFC, 0x8A, + 0x8C, 0xD5, 0xD5, 0x27, 0x4C, 0x3E, 0x76, 0x99, + 0xDB, 0xDC, 0x71, 0x1C, 0x97, 0xA7, 0xAA, 0x91, + 0xE2, 0xC5, 0x0A, 0x82, 0xBD, 0x0B, 0x10, 0x34, + 0xF0, 0xDF, 0x49, 0x3D, 0xEC, 0x16, 0x36, 0x24, + 0x27, 0xE5, 0x8A, 0xCC, 0xE7, 0xF6, 0xCE, 0x0F, + 0x9B, 0xCC, 0x61, 0x7B, 0xBD, 0x8C, 0x90, 0xD0, + 0x09, 0x4A, 0x27, 0x03, 0xBA, 0x0D, 0x09, 0xEB, + 0x19, 0xD1, 0x00, 0x5F, 0x2F, 0xB2, 0x65, 0x52, + 0x6A, 0xAC, 0x75, 0xAF, 0x32, 0xF8, 0xBC, 0x78, + 0x2C, 0xDE, 0xD2, 0xA5, 0x7F, 0x81, 0x1E, 0x03, + 0xEA, 0xF6, 0x7A, 0x94, 0x4D, 0xE5, 0xE7, 0x84, + 0x13, 0xDC, 0xA8, 0xF2, 0x32, 0xD0, 0x74, 0xE6, + 0xDC, 0xEA, 0x4C, 0xEC, 0x9F, 0x02, 0x03, 0x01, + 0x00, 0x01 + }; + struct byte_string key = {0}; + key.value = value; + key.size = ARRAY_LENGTH(value); + + struct key_value kv = {0}; + kv.key_material = &key; + + struct key_block kb = {0}; + kb.key_format_type = KMIP_KEYFORMAT_X509; + kb.key_value = &kv; + kb.cryptographic_algorithm = KMIP_CRYPTOALG_RSA; + kb.cryptographic_length = 1024; + + struct public_key pk = {0}; + pk.key_block = &kb; + + int result = kmip_encode_public_key(&ctx, &pk); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_decode_public_key(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[248] = { + 0x42, 0x00, 0x6D, 0x01, 0x00, 0x00, 0x00, 0xF0, + 0x42, 0x00, 0x40, 0x01, 0x00, 0x00, 0x00, 0xE8, + 0x42, 0x00, 0x42, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x45, 0x01, 0x00, 0x00, 0x00, 0xB0, + 0x42, 0x00, 0x43, 0x08, 0x00, 0x00, 0x00, 0xA2, + 0x30, 0x81, 0x9F, 0x30, 0x0D, 0x06, 0x09, 0x2A, + 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x01, + 0x05, 0x00, 0x03, 0x81, 0x8D, 0x00, 0x30, 0x81, + 0x89, 0x02, 0x81, 0x81, 0x00, 0x93, 0x04, 0x51, + 0xC9, 0xEC, 0xD9, 0x4F, 0x5B, 0xB9, 0xDA, 0x17, + 0xDD, 0x09, 0x38, 0x1B, 0xD2, 0x3B, 0xE4, 0x3E, + 0xCA, 0x8C, 0x75, 0x39, 0xF3, 0x01, 0xFC, 0x8A, + 0x8C, 0xD5, 0xD5, 0x27, 0x4C, 0x3E, 0x76, 0x99, + 0xDB, 0xDC, 0x71, 0x1C, 0x97, 0xA7, 0xAA, 0x91, + 0xE2, 0xC5, 0x0A, 0x82, 0xBD, 0x0B, 0x10, 0x34, + 0xF0, 0xDF, 0x49, 0x3D, 0xEC, 0x16, 0x36, 0x24, + 0x27, 0xE5, 0x8A, 0xCC, 0xE7, 0xF6, 0xCE, 0x0F, + 0x9B, 0xCC, 0x61, 0x7B, 0xBD, 0x8C, 0x90, 0xD0, + 0x09, 0x4A, 0x27, 0x03, 0xBA, 0x0D, 0x09, 0xEB, + 0x19, 0xD1, 0x00, 0x5F, 0x2F, 0xB2, 0x65, 0x52, + 0x6A, 0xAC, 0x75, 0xAF, 0x32, 0xF8, 0xBC, 0x78, + 0x2C, 0xDE, 0xD2, 0xA5, 0x7F, 0x81, 0x1E, 0x03, + 0xEA, 0xF6, 0x7A, 0x94, 0x4D, 0xE5, 0xE7, 0x84, + 0x13, 0xDC, 0xA8, 0xF2, 0x32, 0xD0, 0x74, 0xE6, + 0xDC, 0xEA, 0x4C, 0xEC, 0x9F, 0x02, 0x03, 0x01, + 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x28, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x2A, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00 + }; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0); + + uint8 value[162] = { + 0x30, 0x81, 0x9F, 0x30, 0x0D, 0x06, 0x09, 0x2A, + 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x01, + 0x05, 0x00, 0x03, 0x81, 0x8D, 0x00, 0x30, 0x81, + 0x89, 0x02, 0x81, 0x81, 0x00, 0x93, 0x04, 0x51, + 0xC9, 0xEC, 0xD9, 0x4F, 0x5B, 0xB9, 0xDA, 0x17, + 0xDD, 0x09, 0x38, 0x1B, 0xD2, 0x3B, 0xE4, 0x3E, + 0xCA, 0x8C, 0x75, 0x39, 0xF3, 0x01, 0xFC, 0x8A, + 0x8C, 0xD5, 0xD5, 0x27, 0x4C, 0x3E, 0x76, 0x99, + 0xDB, 0xDC, 0x71, 0x1C, 0x97, 0xA7, 0xAA, 0x91, + 0xE2, 0xC5, 0x0A, 0x82, 0xBD, 0x0B, 0x10, 0x34, + 0xF0, 0xDF, 0x49, 0x3D, 0xEC, 0x16, 0x36, 0x24, + 0x27, 0xE5, 0x8A, 0xCC, 0xE7, 0xF6, 0xCE, 0x0F, + 0x9B, 0xCC, 0x61, 0x7B, 0xBD, 0x8C, 0x90, 0xD0, + 0x09, 0x4A, 0x27, 0x03, 0xBA, 0x0D, 0x09, 0xEB, + 0x19, 0xD1, 0x00, 0x5F, 0x2F, 0xB2, 0x65, 0x52, + 0x6A, 0xAC, 0x75, 0xAF, 0x32, 0xF8, 0xBC, 0x78, + 0x2C, 0xDE, 0xD2, 0xA5, 0x7F, 0x81, 0x1E, 0x03, + 0xEA, 0xF6, 0x7A, 0x94, 0x4D, 0xE5, 0xE7, 0x84, + 0x13, 0xDC, 0xA8, 0xF2, 0x32, 0xD0, 0x74, 0xE6, + 0xDC, 0xEA, 0x4C, 0xEC, 0x9F, 0x02, 0x03, 0x01, + 0x00, 0x01 + }; + struct byte_string key = {0}; + key.value = value; + key.size = ARRAY_LENGTH(value); + + struct key_value kv = {0}; + kv.key_material = &key; + + struct key_block kb = {0}; + kb.key_format_type = KMIP_KEYFORMAT_X509; + kb.key_value = &kv; + kb.key_value_type = KMIP_TYPE_STRUCTURE; + kb.cryptographic_algorithm = KMIP_CRYPTOALG_RSA; + kb.cryptographic_length = 1024; + + struct public_key expected = {0}; + expected.key_block = &kb; + + struct public_key observed = {0}; + + int result = kmip_decode_public_key(&ctx, &observed); + result = report_decoding_test_result( + tracker, + &ctx, + kmip_compare_public_key(&expected, &observed), + result, + __func__); + kmip_free_public_key(&ctx, &observed); + kmip_destroy(&ctx); + return(result); +} + +int +test_encode_private_key(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 expected[1280] = { + 0x42, 0x00, 0x64, 0x01, 0x00, 0x00, 0x04, 0xF8, + 0x42, 0x00, 0x40, 0x01, 0x00, 0x00, 0x04, 0xF0, + 0x42, 0x00, 0x42, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x45, 0x01, 0x00, 0x00, 0x04, 0xB8, + 0x42, 0x00, 0x43, 0x08, 0x00, 0x00, 0x04, 0xA9, + 0x30, 0x82, 0x04, 0xA5, 0x02, 0x01, 0x00, 0x02, + 0x82, 0x01, 0x01, 0x00, 0xAB, 0x7F, 0x16, 0x1C, + 0x00, 0x42, 0x49, 0x6C, 0xCD, 0x6C, 0x6D, 0x4D, + 0xAD, 0xB9, 0x19, 0x97, 0x34, 0x35, 0x35, 0x77, + 0x76, 0x00, 0x3A, 0xCF, 0x54, 0xB7, 0xAF, 0x1E, + 0x44, 0x0A, 0xFB, 0x80, 0xB6, 0x4A, 0x87, 0x55, + 0xF8, 0x00, 0x2C, 0xFE, 0xBA, 0x6B, 0x18, 0x45, + 0x40, 0xA2, 0xD6, 0x60, 0x86, 0xD7, 0x46, 0x48, + 0x34, 0x6D, 0x75, 0xB8, 0xD7, 0x18, 0x12, 0xB2, + 0x05, 0x38, 0x7C, 0x0F, 0x65, 0x83, 0xBC, 0x4D, + 0x7D, 0xC7, 0xEC, 0x11, 0x4F, 0x3B, 0x17, 0x6B, + 0x79, 0x57, 0xC4, 0x22, 0xE7, 0xD0, 0x3F, 0xC6, + 0x26, 0x7F, 0xA2, 0xA6, 0xF8, 0x9B, 0x9B, 0xEE, + 0x9E, 0x60, 0xA1, 0xD7, 0xC2, 0xD8, 0x33, 0xE5, + 0xA5, 0xF4, 0xBB, 0x0B, 0x14, 0x34, 0xF4, 0xE7, + 0x95, 0xA4, 0x11, 0x00, 0xF8, 0xAA, 0x21, 0x49, + 0x00, 0xDF, 0x8B, 0x65, 0x08, 0x9F, 0x98, 0x13, + 0x5B, 0x1C, 0x67, 0xB7, 0x01, 0x67, 0x5A, 0xBD, + 0xBC, 0x7D, 0x57, 0x21, 0xAA, 0xC9, 0xD1, 0x4A, + 0x7F, 0x08, 0x1F, 0xCE, 0xC8, 0x0B, 0x64, 0xE8, + 0xA0, 0xEC, 0xC8, 0x29, 0x53, 0x53, 0xC7, 0x95, + 0x32, 0x8A, 0xBF, 0x70, 0xE1, 0xB4, 0x2E, 0x7B, + 0xB8, 0xB7, 0xF4, 0xE8, 0xAC, 0x8C, 0x81, 0x0C, + 0xDB, 0x66, 0xE3, 0xD2, 0x11, 0x26, 0xEB, 0xA8, + 0xDA, 0x7D, 0x0C, 0xA3, 0x41, 0x42, 0xCB, 0x76, + 0xF9, 0x1F, 0x01, 0x3D, 0xA8, 0x09, 0xE9, 0xC1, + 0xB7, 0xAE, 0x64, 0xC5, 0x41, 0x30, 0xFB, 0xC2, + 0x1D, 0x80, 0xE9, 0xC2, 0xCB, 0x06, 0xC5, 0xC8, + 0xD7, 0xCC, 0xE8, 0x94, 0x6A, 0x9A, 0xC9, 0x9B, + 0x1C, 0x28, 0x15, 0xC3, 0x61, 0x2A, 0x29, 0xA8, + 0x2D, 0x73, 0xA1, 0xF9, 0x93, 0x74, 0xFE, 0x30, + 0xE5, 0x49, 0x51, 0x66, 0x2A, 0x6E, 0xDA, 0x29, + 0xC6, 0xFC, 0x41, 0x13, 0x35, 0xD5, 0xDC, 0x74, + 0x26, 0xB0, 0xF6, 0x05, 0x02, 0x03, 0x01, 0x00, + 0x01, 0x02, 0x82, 0x01, 0x00, 0x3B, 0x12, 0x45, + 0x5D, 0x53, 0xC1, 0x81, 0x65, 0x16, 0xC5, 0x18, + 0x49, 0x3F, 0x63, 0x98, 0xAA, 0xFA, 0x72, 0xB1, + 0x7D, 0xFA, 0x89, 0x4D, 0xB8, 0x88, 0xA7, 0xD4, + 0x8C, 0x0A, 0x47, 0xF6, 0x25, 0x79, 0xA4, 0xE6, + 0x44, 0xF8, 0x6D, 0xA7, 0x11, 0xFE, 0xC8, 0x50, + 0xCD, 0xD9, 0xDB, 0xBD, 0x17, 0xF6, 0x9A, 0x44, + 0x3D, 0x2E, 0xC1, 0xDD, 0x60, 0xD3, 0xC6, 0x18, + 0xFA, 0x74, 0xCD, 0xE5, 0xFD, 0xAF, 0xAB, 0xD6, + 0xBA, 0xA2, 0x6E, 0xB0, 0xA3, 0xAD, 0xB4, 0xDE, + 0xF6, 0x48, 0x0F, 0xB1, 0x21, 0x8C, 0xD3, 0xB0, + 0x83, 0xE2, 0x52, 0xE8, 0x85, 0xB6, 0xF0, 0x72, + 0x9F, 0x98, 0xB2, 0x14, 0x4D, 0x2B, 0x72, 0x29, + 0x3E, 0x1B, 0x11, 0xD7, 0x33, 0x93, 0xBC, 0x41, + 0xF7, 0x5B, 0x15, 0xEE, 0x3D, 0x75, 0x69, 0xB4, + 0x99, 0x5E, 0xD1, 0xA1, 0x44, 0x25, 0xDA, 0x43, + 0x19, 0xB7, 0xB2, 0x6B, 0x0E, 0x8F, 0xEF, 0x17, + 0xC3, 0x75, 0x42, 0xAE, 0x5C, 0x6D, 0x58, 0x49, + 0xF8, 0x72, 0x09, 0x56, 0x7F, 0x39, 0x25, 0xA4, + 0x7B, 0x01, 0x6D, 0x56, 0x48, 0x59, 0x71, 0x7B, + 0xC5, 0x7F, 0xCB, 0x45, 0x22, 0xD0, 0xAA, 0x49, + 0xCE, 0x81, 0x6E, 0x5B, 0xE7, 0xB3, 0x08, 0x81, + 0x93, 0x23, 0x6E, 0xC9, 0xEF, 0xFF, 0x14, 0x08, + 0x58, 0x04, 0x5B, 0x73, 0xC5, 0xD7, 0x9B, 0xAF, + 0x38, 0xF7, 0xC6, 0x7F, 0x04, 0xC5, 0xDC, 0xF0, + 0xE3, 0x80, 0x6A, 0xD9, 0x82, 0xD1, 0x25, 0x90, + 0x58, 0xC3, 0x47, 0x3E, 0x84, 0x71, 0x79, 0xA8, + 0x78, 0xF2, 0xC6, 0xB3, 0xBD, 0x96, 0x8F, 0xB9, + 0x9E, 0xA4, 0x6E, 0x91, 0x85, 0x89, 0x2F, 0x36, + 0x76, 0xE7, 0x89, 0x65, 0xC2, 0xAE, 0xD4, 0x87, + 0x7B, 0xA3, 0x91, 0x7D, 0xF0, 0x7C, 0x5E, 0x92, + 0x74, 0x74, 0xF1, 0x9E, 0x76, 0x4B, 0xA6, 0x1D, + 0xC3, 0x8D, 0x63, 0xBF, 0x29, 0x02, 0x81, 0x81, + 0x00, 0xD5, 0xC6, 0x9C, 0x8C, 0x3C, 0xDC, 0x24, + 0x64, 0x74, 0x4A, 0x79, 0x37, 0x13, 0xDA, 0xFB, + 0x9F, 0x1D, 0xBC, 0x79, 0x9F, 0xF9, 0x64, 0x23, + 0xFE, 0xCD, 0x3C, 0xBA, 0x79, 0x42, 0x86, 0xBC, + 0xE9, 0x20, 0xF4, 0xB5, 0xC1, 0x83, 0xF9, 0x9E, + 0xE9, 0x02, 0x8D, 0xB6, 0x21, 0x2C, 0x62, 0x77, + 0xC4, 0xC8, 0x29, 0x7F, 0xCF, 0xBC, 0xE7, 0xF7, + 0xC2, 0x4C, 0xA4, 0xC5, 0x1F, 0xC7, 0x18, 0x2F, + 0xB8, 0xF4, 0x01, 0x9F, 0xB1, 0xD5, 0x65, 0x96, + 0x74, 0xC5, 0xCB, 0xE6, 0xD5, 0xFA, 0x99, 0x20, + 0x51, 0x34, 0x17, 0x60, 0xCD, 0x00, 0x73, 0x57, + 0x29, 0xA0, 0x70, 0xA9, 0xE5, 0x4D, 0x34, 0x2B, + 0xEB, 0xA8, 0xEF, 0x47, 0xEE, 0x82, 0xD3, 0xA0, + 0x1B, 0x04, 0xCE, 0xC4, 0xA0, 0x0D, 0x4D, 0xDB, + 0x41, 0xE3, 0x51, 0x16, 0xFC, 0x22, 0x1E, 0x85, + 0x4B, 0x43, 0xA6, 0x96, 0xC0, 0xE6, 0x41, 0x9B, + 0x1B, 0x02, 0x81, 0x81, 0x00, 0xCD, 0x5E, 0xA7, + 0x70, 0x27, 0x89, 0x06, 0x4B, 0x67, 0x35, 0x40, + 0xCB, 0xFF, 0x09, 0x35, 0x6A, 0xD8, 0x0B, 0xC3, + 0xD5, 0x92, 0x81, 0x2E, 0xBA, 0x47, 0x61, 0x0B, + 0x9F, 0xAC, 0x6A, 0xEC, 0xEF, 0xE2, 0x2A, 0xCA, + 0xE4, 0x38, 0x45, 0x9C, 0xDA, 0x74, 0xE5, 0x96, + 0x53, 0xD8, 0x8C, 0x04, 0x18, 0x9D, 0x34, 0x39, + 0x9B, 0xF5, 0xB1, 0x4B, 0x92, 0x0E, 0x34, 0xEF, + 0x38, 0xA7, 0xD0, 0x9F, 0xE6, 0x95, 0x93, 0x39, + 0x6E, 0x8F, 0xE7, 0x35, 0xE6, 0xF0, 0xA6, 0xAE, + 0x49, 0x90, 0x40, 0x10, 0x41, 0xD8, 0xA4, 0x06, + 0xB6, 0xFD, 0x86, 0xA1, 0x16, 0x1E, 0x45, 0xF9, + 0x5A, 0x3E, 0xAA, 0x5C, 0x10, 0x12, 0xE6, 0x66, + 0x2E, 0x44, 0xF1, 0x5F, 0x33, 0x5A, 0xC9, 0x71, + 0xE1, 0x76, 0x6B, 0x2B, 0xB9, 0xC9, 0x85, 0x10, + 0x99, 0x74, 0x14, 0x1B, 0x44, 0xD3, 0x7E, 0x1E, + 0x31, 0x98, 0x20, 0xA5, 0x5F, 0x02, 0x81, 0x81, + 0x00, 0xB2, 0x87, 0x12, 0x37, 0xBF, 0x9F, 0xAD, + 0x38, 0xC3, 0x31, 0x6A, 0xB7, 0x87, 0x7A, 0x6A, + 0x86, 0x80, 0x63, 0xE5, 0x42, 0xA7, 0x18, 0x6D, + 0x43, 0x1E, 0x8D, 0x27, 0xC1, 0x9A, 0xC0, 0x41, + 0x45, 0x84, 0x03, 0x39, 0x42, 0xE9, 0xFF, 0x6E, + 0x29, 0x73, 0xBB, 0x7B, 0x2D, 0x8B, 0x0E, 0x94, + 0xAD, 0x1E, 0xE8, 0x21, 0x58, 0x10, 0x8F, 0xBC, + 0x86, 0x64, 0x51, 0x7A, 0x5A, 0x46, 0x7F, 0xB9, + 0x63, 0x01, 0x4B, 0xD5, 0xDC, 0xC2, 0xB4, 0xFB, + 0x08, 0x7C, 0x23, 0x03, 0x9D, 0x11, 0x92, 0x0D, + 0xBE, 0x22, 0xFD, 0x9F, 0x16, 0xB4, 0xD8, 0x9E, + 0x23, 0x22, 0x5C, 0xD4, 0x55, 0xAD, 0xBA, 0xF3, + 0x2E, 0xF4, 0x3F, 0x18, 0x58, 0x64, 0xA3, 0x6D, + 0x63, 0x03, 0x09, 0xD6, 0x85, 0x3F, 0x77, 0x14, + 0xB3, 0x9A, 0xAE, 0x1E, 0xBE, 0xE3, 0x93, 0x8F, + 0x87, 0xC2, 0x70, 0x7E, 0x17, 0x8C, 0x73, 0x9F, + 0x9F, 0x02, 0x81, 0x81, 0x00, 0x96, 0x90, 0xBE, + 0xD1, 0x4B, 0x2A, 0xFA, 0xA2, 0x6D, 0x98, 0x6D, + 0x59, 0x22, 0x31, 0xEE, 0x27, 0xD7, 0x1D, 0x49, + 0x06, 0x5B, 0xD2, 0xBA, 0x1F, 0x78, 0x15, 0x7E, + 0x20, 0x22, 0x98, 0x81, 0xFD, 0x9D, 0x23, 0x22, + 0x7D, 0x0F, 0x84, 0x79, 0xEA, 0xEF, 0xA9, 0x22, + 0xFD, 0x75, 0xD5, 0xB1, 0x6B, 0x1A, 0x56, 0x1F, + 0xA6, 0x68, 0x0B, 0x04, 0x0C, 0xA0, 0xBD, 0xCE, + 0x65, 0x0B, 0x23, 0xB9, 0x17, 0xA4, 0xB1, 0xBB, + 0x79, 0x83, 0xA7, 0x4F, 0xAD, 0x70, 0xE1, 0xC3, + 0x05, 0xCB, 0xEC, 0x2B, 0xFF, 0x1A, 0x85, 0xA7, + 0x26, 0xA1, 0xD9, 0x02, 0x60, 0xE4, 0xF1, 0x08, + 0x4F, 0x51, 0x82, 0x34, 0xDC, 0xD3, 0xFE, 0x77, + 0x0B, 0x95, 0x20, 0x21, 0x5B, 0xD5, 0x43, 0xBB, + 0x6A, 0x41, 0x17, 0x71, 0x87, 0x54, 0x67, 0x6A, + 0x34, 0x17, 0x16, 0x66, 0xA7, 0x9F, 0x26, 0xE7, + 0x9C, 0x14, 0x9C, 0x5A, 0xA1, 0x02, 0x81, 0x81, + 0x00, 0xA0, 0xC9, 0x85, 0xA0, 0xA0, 0xA7, 0x91, + 0xA6, 0x59, 0xF9, 0x97, 0x31, 0x13, 0x4C, 0x44, + 0xF3, 0x7B, 0x2E, 0x52, 0x0A, 0x2C, 0xEA, 0x35, + 0x80, 0x0A, 0xD2, 0x72, 0x41, 0xED, 0x36, 0x0D, + 0xFD, 0xE6, 0xE8, 0xCA, 0x61, 0x4F, 0x12, 0x04, + 0x7F, 0xD0, 0x8B, 0x76, 0xAC, 0x4D, 0x13, 0xC0, + 0x56, 0xA0, 0x69, 0x9E, 0x2F, 0x98, 0xA1, 0xCA, + 0xC9, 0x10, 0x11, 0x29, 0x4D, 0x71, 0x20, 0x8F, + 0x4A, 0xBA, 0xB3, 0x3B, 0xA8, 0x7A, 0xA0, 0x51, + 0x7F, 0x41, 0x5B, 0xAC, 0xA8, 0x8D, 0x6B, 0xAC, + 0x00, 0x60, 0x88, 0xFA, 0x60, 0x1D, 0x34, 0x94, + 0x17, 0xE1, 0xF0, 0xC9, 0xB2, 0x3A, 0xFF, 0xA4, + 0xD4, 0x96, 0x61, 0x8D, 0xBC, 0x02, 0x49, 0x86, + 0xED, 0x69, 0x0B, 0xBB, 0x7B, 0x02, 0x57, 0x68, + 0xFF, 0x9D, 0xF8, 0xAC, 0x15, 0x41, 0x6F, 0x48, + 0x9F, 0x81, 0x29, 0xC3, 0x23, 0x41, 0xA8, 0xB4, + 0x4F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x28, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x2A, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[1280] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0); + + uint8 value[1193] = { + 0x30, 0x82, 0x04, 0xA5, 0x02, 0x01, 0x00, 0x02, + 0x82, 0x01, 0x01, 0x00, 0xAB, 0x7F, 0x16, 0x1C, + 0x00, 0x42, 0x49, 0x6C, 0xCD, 0x6C, 0x6D, 0x4D, + 0xAD, 0xB9, 0x19, 0x97, 0x34, 0x35, 0x35, 0x77, + 0x76, 0x00, 0x3A, 0xCF, 0x54, 0xB7, 0xAF, 0x1E, + 0x44, 0x0A, 0xFB, 0x80, 0xB6, 0x4A, 0x87, 0x55, + 0xF8, 0x00, 0x2C, 0xFE, 0xBA, 0x6B, 0x18, 0x45, + 0x40, 0xA2, 0xD6, 0x60, 0x86, 0xD7, 0x46, 0x48, + 0x34, 0x6D, 0x75, 0xB8, 0xD7, 0x18, 0x12, 0xB2, + 0x05, 0x38, 0x7C, 0x0F, 0x65, 0x83, 0xBC, 0x4D, + 0x7D, 0xC7, 0xEC, 0x11, 0x4F, 0x3B, 0x17, 0x6B, + 0x79, 0x57, 0xC4, 0x22, 0xE7, 0xD0, 0x3F, 0xC6, + 0x26, 0x7F, 0xA2, 0xA6, 0xF8, 0x9B, 0x9B, 0xEE, + 0x9E, 0x60, 0xA1, 0xD7, 0xC2, 0xD8, 0x33, 0xE5, + 0xA5, 0xF4, 0xBB, 0x0B, 0x14, 0x34, 0xF4, 0xE7, + 0x95, 0xA4, 0x11, 0x00, 0xF8, 0xAA, 0x21, 0x49, + 0x00, 0xDF, 0x8B, 0x65, 0x08, 0x9F, 0x98, 0x13, + 0x5B, 0x1C, 0x67, 0xB7, 0x01, 0x67, 0x5A, 0xBD, + 0xBC, 0x7D, 0x57, 0x21, 0xAA, 0xC9, 0xD1, 0x4A, + 0x7F, 0x08, 0x1F, 0xCE, 0xC8, 0x0B, 0x64, 0xE8, + 0xA0, 0xEC, 0xC8, 0x29, 0x53, 0x53, 0xC7, 0x95, + 0x32, 0x8A, 0xBF, 0x70, 0xE1, 0xB4, 0x2E, 0x7B, + 0xB8, 0xB7, 0xF4, 0xE8, 0xAC, 0x8C, 0x81, 0x0C, + 0xDB, 0x66, 0xE3, 0xD2, 0x11, 0x26, 0xEB, 0xA8, + 0xDA, 0x7D, 0x0C, 0xA3, 0x41, 0x42, 0xCB, 0x76, + 0xF9, 0x1F, 0x01, 0x3D, 0xA8, 0x09, 0xE9, 0xC1, + 0xB7, 0xAE, 0x64, 0xC5, 0x41, 0x30, 0xFB, 0xC2, + 0x1D, 0x80, 0xE9, 0xC2, 0xCB, 0x06, 0xC5, 0xC8, + 0xD7, 0xCC, 0xE8, 0x94, 0x6A, 0x9A, 0xC9, 0x9B, + 0x1C, 0x28, 0x15, 0xC3, 0x61, 0x2A, 0x29, 0xA8, + 0x2D, 0x73, 0xA1, 0xF9, 0x93, 0x74, 0xFE, 0x30, + 0xE5, 0x49, 0x51, 0x66, 0x2A, 0x6E, 0xDA, 0x29, + 0xC6, 0xFC, 0x41, 0x13, 0x35, 0xD5, 0xDC, 0x74, + 0x26, 0xB0, 0xF6, 0x05, 0x02, 0x03, 0x01, 0x00, + 0x01, 0x02, 0x82, 0x01, 0x00, 0x3B, 0x12, 0x45, + 0x5D, 0x53, 0xC1, 0x81, 0x65, 0x16, 0xC5, 0x18, + 0x49, 0x3F, 0x63, 0x98, 0xAA, 0xFA, 0x72, 0xB1, + 0x7D, 0xFA, 0x89, 0x4D, 0xB8, 0x88, 0xA7, 0xD4, + 0x8C, 0x0A, 0x47, 0xF6, 0x25, 0x79, 0xA4, 0xE6, + 0x44, 0xF8, 0x6D, 0xA7, 0x11, 0xFE, 0xC8, 0x50, + 0xCD, 0xD9, 0xDB, 0xBD, 0x17, 0xF6, 0x9A, 0x44, + 0x3D, 0x2E, 0xC1, 0xDD, 0x60, 0xD3, 0xC6, 0x18, + 0xFA, 0x74, 0xCD, 0xE5, 0xFD, 0xAF, 0xAB, 0xD6, + 0xBA, 0xA2, 0x6E, 0xB0, 0xA3, 0xAD, 0xB4, 0xDE, + 0xF6, 0x48, 0x0F, 0xB1, 0x21, 0x8C, 0xD3, 0xB0, + 0x83, 0xE2, 0x52, 0xE8, 0x85, 0xB6, 0xF0, 0x72, + 0x9F, 0x98, 0xB2, 0x14, 0x4D, 0x2B, 0x72, 0x29, + 0x3E, 0x1B, 0x11, 0xD7, 0x33, 0x93, 0xBC, 0x41, + 0xF7, 0x5B, 0x15, 0xEE, 0x3D, 0x75, 0x69, 0xB4, + 0x99, 0x5E, 0xD1, 0xA1, 0x44, 0x25, 0xDA, 0x43, + 0x19, 0xB7, 0xB2, 0x6B, 0x0E, 0x8F, 0xEF, 0x17, + 0xC3, 0x75, 0x42, 0xAE, 0x5C, 0x6D, 0x58, 0x49, + 0xF8, 0x72, 0x09, 0x56, 0x7F, 0x39, 0x25, 0xA4, + 0x7B, 0x01, 0x6D, 0x56, 0x48, 0x59, 0x71, 0x7B, + 0xC5, 0x7F, 0xCB, 0x45, 0x22, 0xD0, 0xAA, 0x49, + 0xCE, 0x81, 0x6E, 0x5B, 0xE7, 0xB3, 0x08, 0x81, + 0x93, 0x23, 0x6E, 0xC9, 0xEF, 0xFF, 0x14, 0x08, + 0x58, 0x04, 0x5B, 0x73, 0xC5, 0xD7, 0x9B, 0xAF, + 0x38, 0xF7, 0xC6, 0x7F, 0x04, 0xC5, 0xDC, 0xF0, + 0xE3, 0x80, 0x6A, 0xD9, 0x82, 0xD1, 0x25, 0x90, + 0x58, 0xC3, 0x47, 0x3E, 0x84, 0x71, 0x79, 0xA8, + 0x78, 0xF2, 0xC6, 0xB3, 0xBD, 0x96, 0x8F, 0xB9, + 0x9E, 0xA4, 0x6E, 0x91, 0x85, 0x89, 0x2F, 0x36, + 0x76, 0xE7, 0x89, 0x65, 0xC2, 0xAE, 0xD4, 0x87, + 0x7B, 0xA3, 0x91, 0x7D, 0xF0, 0x7C, 0x5E, 0x92, + 0x74, 0x74, 0xF1, 0x9E, 0x76, 0x4B, 0xA6, 0x1D, + 0xC3, 0x8D, 0x63, 0xBF, 0x29, 0x02, 0x81, 0x81, + 0x00, 0xD5, 0xC6, 0x9C, 0x8C, 0x3C, 0xDC, 0x24, + 0x64, 0x74, 0x4A, 0x79, 0x37, 0x13, 0xDA, 0xFB, + 0x9F, 0x1D, 0xBC, 0x79, 0x9F, 0xF9, 0x64, 0x23, + 0xFE, 0xCD, 0x3C, 0xBA, 0x79, 0x42, 0x86, 0xBC, + 0xE9, 0x20, 0xF4, 0xB5, 0xC1, 0x83, 0xF9, 0x9E, + 0xE9, 0x02, 0x8D, 0xB6, 0x21, 0x2C, 0x62, 0x77, + 0xC4, 0xC8, 0x29, 0x7F, 0xCF, 0xBC, 0xE7, 0xF7, + 0xC2, 0x4C, 0xA4, 0xC5, 0x1F, 0xC7, 0x18, 0x2F, + 0xB8, 0xF4, 0x01, 0x9F, 0xB1, 0xD5, 0x65, 0x96, + 0x74, 0xC5, 0xCB, 0xE6, 0xD5, 0xFA, 0x99, 0x20, + 0x51, 0x34, 0x17, 0x60, 0xCD, 0x00, 0x73, 0x57, + 0x29, 0xA0, 0x70, 0xA9, 0xE5, 0x4D, 0x34, 0x2B, + 0xEB, 0xA8, 0xEF, 0x47, 0xEE, 0x82, 0xD3, 0xA0, + 0x1B, 0x04, 0xCE, 0xC4, 0xA0, 0x0D, 0x4D, 0xDB, + 0x41, 0xE3, 0x51, 0x16, 0xFC, 0x22, 0x1E, 0x85, + 0x4B, 0x43, 0xA6, 0x96, 0xC0, 0xE6, 0x41, 0x9B, + 0x1B, 0x02, 0x81, 0x81, 0x00, 0xCD, 0x5E, 0xA7, + 0x70, 0x27, 0x89, 0x06, 0x4B, 0x67, 0x35, 0x40, + 0xCB, 0xFF, 0x09, 0x35, 0x6A, 0xD8, 0x0B, 0xC3, + 0xD5, 0x92, 0x81, 0x2E, 0xBA, 0x47, 0x61, 0x0B, + 0x9F, 0xAC, 0x6A, 0xEC, 0xEF, 0xE2, 0x2A, 0xCA, + 0xE4, 0x38, 0x45, 0x9C, 0xDA, 0x74, 0xE5, 0x96, + 0x53, 0xD8, 0x8C, 0x04, 0x18, 0x9D, 0x34, 0x39, + 0x9B, 0xF5, 0xB1, 0x4B, 0x92, 0x0E, 0x34, 0xEF, + 0x38, 0xA7, 0xD0, 0x9F, 0xE6, 0x95, 0x93, 0x39, + 0x6E, 0x8F, 0xE7, 0x35, 0xE6, 0xF0, 0xA6, 0xAE, + 0x49, 0x90, 0x40, 0x10, 0x41, 0xD8, 0xA4, 0x06, + 0xB6, 0xFD, 0x86, 0xA1, 0x16, 0x1E, 0x45, 0xF9, + 0x5A, 0x3E, 0xAA, 0x5C, 0x10, 0x12, 0xE6, 0x66, + 0x2E, 0x44, 0xF1, 0x5F, 0x33, 0x5A, 0xC9, 0x71, + 0xE1, 0x76, 0x6B, 0x2B, 0xB9, 0xC9, 0x85, 0x10, + 0x99, 0x74, 0x14, 0x1B, 0x44, 0xD3, 0x7E, 0x1E, + 0x31, 0x98, 0x20, 0xA5, 0x5F, 0x02, 0x81, 0x81, + 0x00, 0xB2, 0x87, 0x12, 0x37, 0xBF, 0x9F, 0xAD, + 0x38, 0xC3, 0x31, 0x6A, 0xB7, 0x87, 0x7A, 0x6A, + 0x86, 0x80, 0x63, 0xE5, 0x42, 0xA7, 0x18, 0x6D, + 0x43, 0x1E, 0x8D, 0x27, 0xC1, 0x9A, 0xC0, 0x41, + 0x45, 0x84, 0x03, 0x39, 0x42, 0xE9, 0xFF, 0x6E, + 0x29, 0x73, 0xBB, 0x7B, 0x2D, 0x8B, 0x0E, 0x94, + 0xAD, 0x1E, 0xE8, 0x21, 0x58, 0x10, 0x8F, 0xBC, + 0x86, 0x64, 0x51, 0x7A, 0x5A, 0x46, 0x7F, 0xB9, + 0x63, 0x01, 0x4B, 0xD5, 0xDC, 0xC2, 0xB4, 0xFB, + 0x08, 0x7C, 0x23, 0x03, 0x9D, 0x11, 0x92, 0x0D, + 0xBE, 0x22, 0xFD, 0x9F, 0x16, 0xB4, 0xD8, 0x9E, + 0x23, 0x22, 0x5C, 0xD4, 0x55, 0xAD, 0xBA, 0xF3, + 0x2E, 0xF4, 0x3F, 0x18, 0x58, 0x64, 0xA3, 0x6D, + 0x63, 0x03, 0x09, 0xD6, 0x85, 0x3F, 0x77, 0x14, + 0xB3, 0x9A, 0xAE, 0x1E, 0xBE, 0xE3, 0x93, 0x8F, + 0x87, 0xC2, 0x70, 0x7E, 0x17, 0x8C, 0x73, 0x9F, + 0x9F, 0x02, 0x81, 0x81, 0x00, 0x96, 0x90, 0xBE, + 0xD1, 0x4B, 0x2A, 0xFA, 0xA2, 0x6D, 0x98, 0x6D, + 0x59, 0x22, 0x31, 0xEE, 0x27, 0xD7, 0x1D, 0x49, + 0x06, 0x5B, 0xD2, 0xBA, 0x1F, 0x78, 0x15, 0x7E, + 0x20, 0x22, 0x98, 0x81, 0xFD, 0x9D, 0x23, 0x22, + 0x7D, 0x0F, 0x84, 0x79, 0xEA, 0xEF, 0xA9, 0x22, + 0xFD, 0x75, 0xD5, 0xB1, 0x6B, 0x1A, 0x56, 0x1F, + 0xA6, 0x68, 0x0B, 0x04, 0x0C, 0xA0, 0xBD, 0xCE, + 0x65, 0x0B, 0x23, 0xB9, 0x17, 0xA4, 0xB1, 0xBB, + 0x79, 0x83, 0xA7, 0x4F, 0xAD, 0x70, 0xE1, 0xC3, + 0x05, 0xCB, 0xEC, 0x2B, 0xFF, 0x1A, 0x85, 0xA7, + 0x26, 0xA1, 0xD9, 0x02, 0x60, 0xE4, 0xF1, 0x08, + 0x4F, 0x51, 0x82, 0x34, 0xDC, 0xD3, 0xFE, 0x77, + 0x0B, 0x95, 0x20, 0x21, 0x5B, 0xD5, 0x43, 0xBB, + 0x6A, 0x41, 0x17, 0x71, 0x87, 0x54, 0x67, 0x6A, + 0x34, 0x17, 0x16, 0x66, 0xA7, 0x9F, 0x26, 0xE7, + 0x9C, 0x14, 0x9C, 0x5A, 0xA1, 0x02, 0x81, 0x81, + 0x00, 0xA0, 0xC9, 0x85, 0xA0, 0xA0, 0xA7, 0x91, + 0xA6, 0x59, 0xF9, 0x97, 0x31, 0x13, 0x4C, 0x44, + 0xF3, 0x7B, 0x2E, 0x52, 0x0A, 0x2C, 0xEA, 0x35, + 0x80, 0x0A, 0xD2, 0x72, 0x41, 0xED, 0x36, 0x0D, + 0xFD, 0xE6, 0xE8, 0xCA, 0x61, 0x4F, 0x12, 0x04, + 0x7F, 0xD0, 0x8B, 0x76, 0xAC, 0x4D, 0x13, 0xC0, + 0x56, 0xA0, 0x69, 0x9E, 0x2F, 0x98, 0xA1, 0xCA, + 0xC9, 0x10, 0x11, 0x29, 0x4D, 0x71, 0x20, 0x8F, + 0x4A, 0xBA, 0xB3, 0x3B, 0xA8, 0x7A, 0xA0, 0x51, + 0x7F, 0x41, 0x5B, 0xAC, 0xA8, 0x8D, 0x6B, 0xAC, + 0x00, 0x60, 0x88, 0xFA, 0x60, 0x1D, 0x34, 0x94, + 0x17, 0xE1, 0xF0, 0xC9, 0xB2, 0x3A, 0xFF, 0xA4, + 0xD4, 0x96, 0x61, 0x8D, 0xBC, 0x02, 0x49, 0x86, + 0xED, 0x69, 0x0B, 0xBB, 0x7B, 0x02, 0x57, 0x68, + 0xFF, 0x9D, 0xF8, 0xAC, 0x15, 0x41, 0x6F, 0x48, + 0x9F, 0x81, 0x29, 0xC3, 0x23, 0x41, 0xA8, 0xB4, + 0x4F + }; + struct byte_string key = {0}; + key.value = value; + key.size = ARRAY_LENGTH(value); + + struct key_value kv = {0}; + kv.key_material = &key; + + struct key_block kb = {0}; + kb.key_format_type = KMIP_KEYFORMAT_PKCS1; + kb.key_value = &kv; + kb.cryptographic_algorithm = KMIP_CRYPTOALG_RSA; + kb.cryptographic_length = 2048; + + struct private_key pk = {0}; + pk.key_block = &kb; + + int result = kmip_encode_private_key(&ctx, &pk); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_decode_private_key(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[1280] = { + 0x42, 0x00, 0x64, 0x01, 0x00, 0x00, 0x04, 0xF8, + 0x42, 0x00, 0x40, 0x01, 0x00, 0x00, 0x04, 0xF0, + 0x42, 0x00, 0x42, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x45, 0x01, 0x00, 0x00, 0x04, 0xB8, + 0x42, 0x00, 0x43, 0x08, 0x00, 0x00, 0x04, 0xA9, + 0x30, 0x82, 0x04, 0xA5, 0x02, 0x01, 0x00, 0x02, + 0x82, 0x01, 0x01, 0x00, 0xAB, 0x7F, 0x16, 0x1C, + 0x00, 0x42, 0x49, 0x6C, 0xCD, 0x6C, 0x6D, 0x4D, + 0xAD, 0xB9, 0x19, 0x97, 0x34, 0x35, 0x35, 0x77, + 0x76, 0x00, 0x3A, 0xCF, 0x54, 0xB7, 0xAF, 0x1E, + 0x44, 0x0A, 0xFB, 0x80, 0xB6, 0x4A, 0x87, 0x55, + 0xF8, 0x00, 0x2C, 0xFE, 0xBA, 0x6B, 0x18, 0x45, + 0x40, 0xA2, 0xD6, 0x60, 0x86, 0xD7, 0x46, 0x48, + 0x34, 0x6D, 0x75, 0xB8, 0xD7, 0x18, 0x12, 0xB2, + 0x05, 0x38, 0x7C, 0x0F, 0x65, 0x83, 0xBC, 0x4D, + 0x7D, 0xC7, 0xEC, 0x11, 0x4F, 0x3B, 0x17, 0x6B, + 0x79, 0x57, 0xC4, 0x22, 0xE7, 0xD0, 0x3F, 0xC6, + 0x26, 0x7F, 0xA2, 0xA6, 0xF8, 0x9B, 0x9B, 0xEE, + 0x9E, 0x60, 0xA1, 0xD7, 0xC2, 0xD8, 0x33, 0xE5, + 0xA5, 0xF4, 0xBB, 0x0B, 0x14, 0x34, 0xF4, 0xE7, + 0x95, 0xA4, 0x11, 0x00, 0xF8, 0xAA, 0x21, 0x49, + 0x00, 0xDF, 0x8B, 0x65, 0x08, 0x9F, 0x98, 0x13, + 0x5B, 0x1C, 0x67, 0xB7, 0x01, 0x67, 0x5A, 0xBD, + 0xBC, 0x7D, 0x57, 0x21, 0xAA, 0xC9, 0xD1, 0x4A, + 0x7F, 0x08, 0x1F, 0xCE, 0xC8, 0x0B, 0x64, 0xE8, + 0xA0, 0xEC, 0xC8, 0x29, 0x53, 0x53, 0xC7, 0x95, + 0x32, 0x8A, 0xBF, 0x70, 0xE1, 0xB4, 0x2E, 0x7B, + 0xB8, 0xB7, 0xF4, 0xE8, 0xAC, 0x8C, 0x81, 0x0C, + 0xDB, 0x66, 0xE3, 0xD2, 0x11, 0x26, 0xEB, 0xA8, + 0xDA, 0x7D, 0x0C, 0xA3, 0x41, 0x42, 0xCB, 0x76, + 0xF9, 0x1F, 0x01, 0x3D, 0xA8, 0x09, 0xE9, 0xC1, + 0xB7, 0xAE, 0x64, 0xC5, 0x41, 0x30, 0xFB, 0xC2, + 0x1D, 0x80, 0xE9, 0xC2, 0xCB, 0x06, 0xC5, 0xC8, + 0xD7, 0xCC, 0xE8, 0x94, 0x6A, 0x9A, 0xC9, 0x9B, + 0x1C, 0x28, 0x15, 0xC3, 0x61, 0x2A, 0x29, 0xA8, + 0x2D, 0x73, 0xA1, 0xF9, 0x93, 0x74, 0xFE, 0x30, + 0xE5, 0x49, 0x51, 0x66, 0x2A, 0x6E, 0xDA, 0x29, + 0xC6, 0xFC, 0x41, 0x13, 0x35, 0xD5, 0xDC, 0x74, + 0x26, 0xB0, 0xF6, 0x05, 0x02, 0x03, 0x01, 0x00, + 0x01, 0x02, 0x82, 0x01, 0x00, 0x3B, 0x12, 0x45, + 0x5D, 0x53, 0xC1, 0x81, 0x65, 0x16, 0xC5, 0x18, + 0x49, 0x3F, 0x63, 0x98, 0xAA, 0xFA, 0x72, 0xB1, + 0x7D, 0xFA, 0x89, 0x4D, 0xB8, 0x88, 0xA7, 0xD4, + 0x8C, 0x0A, 0x47, 0xF6, 0x25, 0x79, 0xA4, 0xE6, + 0x44, 0xF8, 0x6D, 0xA7, 0x11, 0xFE, 0xC8, 0x50, + 0xCD, 0xD9, 0xDB, 0xBD, 0x17, 0xF6, 0x9A, 0x44, + 0x3D, 0x2E, 0xC1, 0xDD, 0x60, 0xD3, 0xC6, 0x18, + 0xFA, 0x74, 0xCD, 0xE5, 0xFD, 0xAF, 0xAB, 0xD6, + 0xBA, 0xA2, 0x6E, 0xB0, 0xA3, 0xAD, 0xB4, 0xDE, + 0xF6, 0x48, 0x0F, 0xB1, 0x21, 0x8C, 0xD3, 0xB0, + 0x83, 0xE2, 0x52, 0xE8, 0x85, 0xB6, 0xF0, 0x72, + 0x9F, 0x98, 0xB2, 0x14, 0x4D, 0x2B, 0x72, 0x29, + 0x3E, 0x1B, 0x11, 0xD7, 0x33, 0x93, 0xBC, 0x41, + 0xF7, 0x5B, 0x15, 0xEE, 0x3D, 0x75, 0x69, 0xB4, + 0x99, 0x5E, 0xD1, 0xA1, 0x44, 0x25, 0xDA, 0x43, + 0x19, 0xB7, 0xB2, 0x6B, 0x0E, 0x8F, 0xEF, 0x17, + 0xC3, 0x75, 0x42, 0xAE, 0x5C, 0x6D, 0x58, 0x49, + 0xF8, 0x72, 0x09, 0x56, 0x7F, 0x39, 0x25, 0xA4, + 0x7B, 0x01, 0x6D, 0x56, 0x48, 0x59, 0x71, 0x7B, + 0xC5, 0x7F, 0xCB, 0x45, 0x22, 0xD0, 0xAA, 0x49, + 0xCE, 0x81, 0x6E, 0x5B, 0xE7, 0xB3, 0x08, 0x81, + 0x93, 0x23, 0x6E, 0xC9, 0xEF, 0xFF, 0x14, 0x08, + 0x58, 0x04, 0x5B, 0x73, 0xC5, 0xD7, 0x9B, 0xAF, + 0x38, 0xF7, 0xC6, 0x7F, 0x04, 0xC5, 0xDC, 0xF0, + 0xE3, 0x80, 0x6A, 0xD9, 0x82, 0xD1, 0x25, 0x90, + 0x58, 0xC3, 0x47, 0x3E, 0x84, 0x71, 0x79, 0xA8, + 0x78, 0xF2, 0xC6, 0xB3, 0xBD, 0x96, 0x8F, 0xB9, + 0x9E, 0xA4, 0x6E, 0x91, 0x85, 0x89, 0x2F, 0x36, + 0x76, 0xE7, 0x89, 0x65, 0xC2, 0xAE, 0xD4, 0x87, + 0x7B, 0xA3, 0x91, 0x7D, 0xF0, 0x7C, 0x5E, 0x92, + 0x74, 0x74, 0xF1, 0x9E, 0x76, 0x4B, 0xA6, 0x1D, + 0xC3, 0x8D, 0x63, 0xBF, 0x29, 0x02, 0x81, 0x81, + 0x00, 0xD5, 0xC6, 0x9C, 0x8C, 0x3C, 0xDC, 0x24, + 0x64, 0x74, 0x4A, 0x79, 0x37, 0x13, 0xDA, 0xFB, + 0x9F, 0x1D, 0xBC, 0x79, 0x9F, 0xF9, 0x64, 0x23, + 0xFE, 0xCD, 0x3C, 0xBA, 0x79, 0x42, 0x86, 0xBC, + 0xE9, 0x20, 0xF4, 0xB5, 0xC1, 0x83, 0xF9, 0x9E, + 0xE9, 0x02, 0x8D, 0xB6, 0x21, 0x2C, 0x62, 0x77, + 0xC4, 0xC8, 0x29, 0x7F, 0xCF, 0xBC, 0xE7, 0xF7, + 0xC2, 0x4C, 0xA4, 0xC5, 0x1F, 0xC7, 0x18, 0x2F, + 0xB8, 0xF4, 0x01, 0x9F, 0xB1, 0xD5, 0x65, 0x96, + 0x74, 0xC5, 0xCB, 0xE6, 0xD5, 0xFA, 0x99, 0x20, + 0x51, 0x34, 0x17, 0x60, 0xCD, 0x00, 0x73, 0x57, + 0x29, 0xA0, 0x70, 0xA9, 0xE5, 0x4D, 0x34, 0x2B, + 0xEB, 0xA8, 0xEF, 0x47, 0xEE, 0x82, 0xD3, 0xA0, + 0x1B, 0x04, 0xCE, 0xC4, 0xA0, 0x0D, 0x4D, 0xDB, + 0x41, 0xE3, 0x51, 0x16, 0xFC, 0x22, 0x1E, 0x85, + 0x4B, 0x43, 0xA6, 0x96, 0xC0, 0xE6, 0x41, 0x9B, + 0x1B, 0x02, 0x81, 0x81, 0x00, 0xCD, 0x5E, 0xA7, + 0x70, 0x27, 0x89, 0x06, 0x4B, 0x67, 0x35, 0x40, + 0xCB, 0xFF, 0x09, 0x35, 0x6A, 0xD8, 0x0B, 0xC3, + 0xD5, 0x92, 0x81, 0x2E, 0xBA, 0x47, 0x61, 0x0B, + 0x9F, 0xAC, 0x6A, 0xEC, 0xEF, 0xE2, 0x2A, 0xCA, + 0xE4, 0x38, 0x45, 0x9C, 0xDA, 0x74, 0xE5, 0x96, + 0x53, 0xD8, 0x8C, 0x04, 0x18, 0x9D, 0x34, 0x39, + 0x9B, 0xF5, 0xB1, 0x4B, 0x92, 0x0E, 0x34, 0xEF, + 0x38, 0xA7, 0xD0, 0x9F, 0xE6, 0x95, 0x93, 0x39, + 0x6E, 0x8F, 0xE7, 0x35, 0xE6, 0xF0, 0xA6, 0xAE, + 0x49, 0x90, 0x40, 0x10, 0x41, 0xD8, 0xA4, 0x06, + 0xB6, 0xFD, 0x86, 0xA1, 0x16, 0x1E, 0x45, 0xF9, + 0x5A, 0x3E, 0xAA, 0x5C, 0x10, 0x12, 0xE6, 0x66, + 0x2E, 0x44, 0xF1, 0x5F, 0x33, 0x5A, 0xC9, 0x71, + 0xE1, 0x76, 0x6B, 0x2B, 0xB9, 0xC9, 0x85, 0x10, + 0x99, 0x74, 0x14, 0x1B, 0x44, 0xD3, 0x7E, 0x1E, + 0x31, 0x98, 0x20, 0xA5, 0x5F, 0x02, 0x81, 0x81, + 0x00, 0xB2, 0x87, 0x12, 0x37, 0xBF, 0x9F, 0xAD, + 0x38, 0xC3, 0x31, 0x6A, 0xB7, 0x87, 0x7A, 0x6A, + 0x86, 0x80, 0x63, 0xE5, 0x42, 0xA7, 0x18, 0x6D, + 0x43, 0x1E, 0x8D, 0x27, 0xC1, 0x9A, 0xC0, 0x41, + 0x45, 0x84, 0x03, 0x39, 0x42, 0xE9, 0xFF, 0x6E, + 0x29, 0x73, 0xBB, 0x7B, 0x2D, 0x8B, 0x0E, 0x94, + 0xAD, 0x1E, 0xE8, 0x21, 0x58, 0x10, 0x8F, 0xBC, + 0x86, 0x64, 0x51, 0x7A, 0x5A, 0x46, 0x7F, 0xB9, + 0x63, 0x01, 0x4B, 0xD5, 0xDC, 0xC2, 0xB4, 0xFB, + 0x08, 0x7C, 0x23, 0x03, 0x9D, 0x11, 0x92, 0x0D, + 0xBE, 0x22, 0xFD, 0x9F, 0x16, 0xB4, 0xD8, 0x9E, + 0x23, 0x22, 0x5C, 0xD4, 0x55, 0xAD, 0xBA, 0xF3, + 0x2E, 0xF4, 0x3F, 0x18, 0x58, 0x64, 0xA3, 0x6D, + 0x63, 0x03, 0x09, 0xD6, 0x85, 0x3F, 0x77, 0x14, + 0xB3, 0x9A, 0xAE, 0x1E, 0xBE, 0xE3, 0x93, 0x8F, + 0x87, 0xC2, 0x70, 0x7E, 0x17, 0x8C, 0x73, 0x9F, + 0x9F, 0x02, 0x81, 0x81, 0x00, 0x96, 0x90, 0xBE, + 0xD1, 0x4B, 0x2A, 0xFA, 0xA2, 0x6D, 0x98, 0x6D, + 0x59, 0x22, 0x31, 0xEE, 0x27, 0xD7, 0x1D, 0x49, + 0x06, 0x5B, 0xD2, 0xBA, 0x1F, 0x78, 0x15, 0x7E, + 0x20, 0x22, 0x98, 0x81, 0xFD, 0x9D, 0x23, 0x22, + 0x7D, 0x0F, 0x84, 0x79, 0xEA, 0xEF, 0xA9, 0x22, + 0xFD, 0x75, 0xD5, 0xB1, 0x6B, 0x1A, 0x56, 0x1F, + 0xA6, 0x68, 0x0B, 0x04, 0x0C, 0xA0, 0xBD, 0xCE, + 0x65, 0x0B, 0x23, 0xB9, 0x17, 0xA4, 0xB1, 0xBB, + 0x79, 0x83, 0xA7, 0x4F, 0xAD, 0x70, 0xE1, 0xC3, + 0x05, 0xCB, 0xEC, 0x2B, 0xFF, 0x1A, 0x85, 0xA7, + 0x26, 0xA1, 0xD9, 0x02, 0x60, 0xE4, 0xF1, 0x08, + 0x4F, 0x51, 0x82, 0x34, 0xDC, 0xD3, 0xFE, 0x77, + 0x0B, 0x95, 0x20, 0x21, 0x5B, 0xD5, 0x43, 0xBB, + 0x6A, 0x41, 0x17, 0x71, 0x87, 0x54, 0x67, 0x6A, + 0x34, 0x17, 0x16, 0x66, 0xA7, 0x9F, 0x26, 0xE7, + 0x9C, 0x14, 0x9C, 0x5A, 0xA1, 0x02, 0x81, 0x81, + 0x00, 0xA0, 0xC9, 0x85, 0xA0, 0xA0, 0xA7, 0x91, + 0xA6, 0x59, 0xF9, 0x97, 0x31, 0x13, 0x4C, 0x44, + 0xF3, 0x7B, 0x2E, 0x52, 0x0A, 0x2C, 0xEA, 0x35, + 0x80, 0x0A, 0xD2, 0x72, 0x41, 0xED, 0x36, 0x0D, + 0xFD, 0xE6, 0xE8, 0xCA, 0x61, 0x4F, 0x12, 0x04, + 0x7F, 0xD0, 0x8B, 0x76, 0xAC, 0x4D, 0x13, 0xC0, + 0x56, 0xA0, 0x69, 0x9E, 0x2F, 0x98, 0xA1, 0xCA, + 0xC9, 0x10, 0x11, 0x29, 0x4D, 0x71, 0x20, 0x8F, + 0x4A, 0xBA, 0xB3, 0x3B, 0xA8, 0x7A, 0xA0, 0x51, + 0x7F, 0x41, 0x5B, 0xAC, 0xA8, 0x8D, 0x6B, 0xAC, + 0x00, 0x60, 0x88, 0xFA, 0x60, 0x1D, 0x34, 0x94, + 0x17, 0xE1, 0xF0, 0xC9, 0xB2, 0x3A, 0xFF, 0xA4, + 0xD4, 0x96, 0x61, 0x8D, 0xBC, 0x02, 0x49, 0x86, + 0xED, 0x69, 0x0B, 0xBB, 0x7B, 0x02, 0x57, 0x68, + 0xFF, 0x9D, 0xF8, 0xAC, 0x15, 0x41, 0x6F, 0x48, + 0x9F, 0x81, 0x29, 0xC3, 0x23, 0x41, 0xA8, 0xB4, + 0x4F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x28, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x2A, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00 + }; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0); + + uint8 value[1193] = { + 0x30, 0x82, 0x04, 0xA5, 0x02, 0x01, 0x00, 0x02, + 0x82, 0x01, 0x01, 0x00, 0xAB, 0x7F, 0x16, 0x1C, + 0x00, 0x42, 0x49, 0x6C, 0xCD, 0x6C, 0x6D, 0x4D, + 0xAD, 0xB9, 0x19, 0x97, 0x34, 0x35, 0x35, 0x77, + 0x76, 0x00, 0x3A, 0xCF, 0x54, 0xB7, 0xAF, 0x1E, + 0x44, 0x0A, 0xFB, 0x80, 0xB6, 0x4A, 0x87, 0x55, + 0xF8, 0x00, 0x2C, 0xFE, 0xBA, 0x6B, 0x18, 0x45, + 0x40, 0xA2, 0xD6, 0x60, 0x86, 0xD7, 0x46, 0x48, + 0x34, 0x6D, 0x75, 0xB8, 0xD7, 0x18, 0x12, 0xB2, + 0x05, 0x38, 0x7C, 0x0F, 0x65, 0x83, 0xBC, 0x4D, + 0x7D, 0xC7, 0xEC, 0x11, 0x4F, 0x3B, 0x17, 0x6B, + 0x79, 0x57, 0xC4, 0x22, 0xE7, 0xD0, 0x3F, 0xC6, + 0x26, 0x7F, 0xA2, 0xA6, 0xF8, 0x9B, 0x9B, 0xEE, + 0x9E, 0x60, 0xA1, 0xD7, 0xC2, 0xD8, 0x33, 0xE5, + 0xA5, 0xF4, 0xBB, 0x0B, 0x14, 0x34, 0xF4, 0xE7, + 0x95, 0xA4, 0x11, 0x00, 0xF8, 0xAA, 0x21, 0x49, + 0x00, 0xDF, 0x8B, 0x65, 0x08, 0x9F, 0x98, 0x13, + 0x5B, 0x1C, 0x67, 0xB7, 0x01, 0x67, 0x5A, 0xBD, + 0xBC, 0x7D, 0x57, 0x21, 0xAA, 0xC9, 0xD1, 0x4A, + 0x7F, 0x08, 0x1F, 0xCE, 0xC8, 0x0B, 0x64, 0xE8, + 0xA0, 0xEC, 0xC8, 0x29, 0x53, 0x53, 0xC7, 0x95, + 0x32, 0x8A, 0xBF, 0x70, 0xE1, 0xB4, 0x2E, 0x7B, + 0xB8, 0xB7, 0xF4, 0xE8, 0xAC, 0x8C, 0x81, 0x0C, + 0xDB, 0x66, 0xE3, 0xD2, 0x11, 0x26, 0xEB, 0xA8, + 0xDA, 0x7D, 0x0C, 0xA3, 0x41, 0x42, 0xCB, 0x76, + 0xF9, 0x1F, 0x01, 0x3D, 0xA8, 0x09, 0xE9, 0xC1, + 0xB7, 0xAE, 0x64, 0xC5, 0x41, 0x30, 0xFB, 0xC2, + 0x1D, 0x80, 0xE9, 0xC2, 0xCB, 0x06, 0xC5, 0xC8, + 0xD7, 0xCC, 0xE8, 0x94, 0x6A, 0x9A, 0xC9, 0x9B, + 0x1C, 0x28, 0x15, 0xC3, 0x61, 0x2A, 0x29, 0xA8, + 0x2D, 0x73, 0xA1, 0xF9, 0x93, 0x74, 0xFE, 0x30, + 0xE5, 0x49, 0x51, 0x66, 0x2A, 0x6E, 0xDA, 0x29, + 0xC6, 0xFC, 0x41, 0x13, 0x35, 0xD5, 0xDC, 0x74, + 0x26, 0xB0, 0xF6, 0x05, 0x02, 0x03, 0x01, 0x00, + 0x01, 0x02, 0x82, 0x01, 0x00, 0x3B, 0x12, 0x45, + 0x5D, 0x53, 0xC1, 0x81, 0x65, 0x16, 0xC5, 0x18, + 0x49, 0x3F, 0x63, 0x98, 0xAA, 0xFA, 0x72, 0xB1, + 0x7D, 0xFA, 0x89, 0x4D, 0xB8, 0x88, 0xA7, 0xD4, + 0x8C, 0x0A, 0x47, 0xF6, 0x25, 0x79, 0xA4, 0xE6, + 0x44, 0xF8, 0x6D, 0xA7, 0x11, 0xFE, 0xC8, 0x50, + 0xCD, 0xD9, 0xDB, 0xBD, 0x17, 0xF6, 0x9A, 0x44, + 0x3D, 0x2E, 0xC1, 0xDD, 0x60, 0xD3, 0xC6, 0x18, + 0xFA, 0x74, 0xCD, 0xE5, 0xFD, 0xAF, 0xAB, 0xD6, + 0xBA, 0xA2, 0x6E, 0xB0, 0xA3, 0xAD, 0xB4, 0xDE, + 0xF6, 0x48, 0x0F, 0xB1, 0x21, 0x8C, 0xD3, 0xB0, + 0x83, 0xE2, 0x52, 0xE8, 0x85, 0xB6, 0xF0, 0x72, + 0x9F, 0x98, 0xB2, 0x14, 0x4D, 0x2B, 0x72, 0x29, + 0x3E, 0x1B, 0x11, 0xD7, 0x33, 0x93, 0xBC, 0x41, + 0xF7, 0x5B, 0x15, 0xEE, 0x3D, 0x75, 0x69, 0xB4, + 0x99, 0x5E, 0xD1, 0xA1, 0x44, 0x25, 0xDA, 0x43, + 0x19, 0xB7, 0xB2, 0x6B, 0x0E, 0x8F, 0xEF, 0x17, + 0xC3, 0x75, 0x42, 0xAE, 0x5C, 0x6D, 0x58, 0x49, + 0xF8, 0x72, 0x09, 0x56, 0x7F, 0x39, 0x25, 0xA4, + 0x7B, 0x01, 0x6D, 0x56, 0x48, 0x59, 0x71, 0x7B, + 0xC5, 0x7F, 0xCB, 0x45, 0x22, 0xD0, 0xAA, 0x49, + 0xCE, 0x81, 0x6E, 0x5B, 0xE7, 0xB3, 0x08, 0x81, + 0x93, 0x23, 0x6E, 0xC9, 0xEF, 0xFF, 0x14, 0x08, + 0x58, 0x04, 0x5B, 0x73, 0xC5, 0xD7, 0x9B, 0xAF, + 0x38, 0xF7, 0xC6, 0x7F, 0x04, 0xC5, 0xDC, 0xF0, + 0xE3, 0x80, 0x6A, 0xD9, 0x82, 0xD1, 0x25, 0x90, + 0x58, 0xC3, 0x47, 0x3E, 0x84, 0x71, 0x79, 0xA8, + 0x78, 0xF2, 0xC6, 0xB3, 0xBD, 0x96, 0x8F, 0xB9, + 0x9E, 0xA4, 0x6E, 0x91, 0x85, 0x89, 0x2F, 0x36, + 0x76, 0xE7, 0x89, 0x65, 0xC2, 0xAE, 0xD4, 0x87, + 0x7B, 0xA3, 0x91, 0x7D, 0xF0, 0x7C, 0x5E, 0x92, + 0x74, 0x74, 0xF1, 0x9E, 0x76, 0x4B, 0xA6, 0x1D, + 0xC3, 0x8D, 0x63, 0xBF, 0x29, 0x02, 0x81, 0x81, + 0x00, 0xD5, 0xC6, 0x9C, 0x8C, 0x3C, 0xDC, 0x24, + 0x64, 0x74, 0x4A, 0x79, 0x37, 0x13, 0xDA, 0xFB, + 0x9F, 0x1D, 0xBC, 0x79, 0x9F, 0xF9, 0x64, 0x23, + 0xFE, 0xCD, 0x3C, 0xBA, 0x79, 0x42, 0x86, 0xBC, + 0xE9, 0x20, 0xF4, 0xB5, 0xC1, 0x83, 0xF9, 0x9E, + 0xE9, 0x02, 0x8D, 0xB6, 0x21, 0x2C, 0x62, 0x77, + 0xC4, 0xC8, 0x29, 0x7F, 0xCF, 0xBC, 0xE7, 0xF7, + 0xC2, 0x4C, 0xA4, 0xC5, 0x1F, 0xC7, 0x18, 0x2F, + 0xB8, 0xF4, 0x01, 0x9F, 0xB1, 0xD5, 0x65, 0x96, + 0x74, 0xC5, 0xCB, 0xE6, 0xD5, 0xFA, 0x99, 0x20, + 0x51, 0x34, 0x17, 0x60, 0xCD, 0x00, 0x73, 0x57, + 0x29, 0xA0, 0x70, 0xA9, 0xE5, 0x4D, 0x34, 0x2B, + 0xEB, 0xA8, 0xEF, 0x47, 0xEE, 0x82, 0xD3, 0xA0, + 0x1B, 0x04, 0xCE, 0xC4, 0xA0, 0x0D, 0x4D, 0xDB, + 0x41, 0xE3, 0x51, 0x16, 0xFC, 0x22, 0x1E, 0x85, + 0x4B, 0x43, 0xA6, 0x96, 0xC0, 0xE6, 0x41, 0x9B, + 0x1B, 0x02, 0x81, 0x81, 0x00, 0xCD, 0x5E, 0xA7, + 0x70, 0x27, 0x89, 0x06, 0x4B, 0x67, 0x35, 0x40, + 0xCB, 0xFF, 0x09, 0x35, 0x6A, 0xD8, 0x0B, 0xC3, + 0xD5, 0x92, 0x81, 0x2E, 0xBA, 0x47, 0x61, 0x0B, + 0x9F, 0xAC, 0x6A, 0xEC, 0xEF, 0xE2, 0x2A, 0xCA, + 0xE4, 0x38, 0x45, 0x9C, 0xDA, 0x74, 0xE5, 0x96, + 0x53, 0xD8, 0x8C, 0x04, 0x18, 0x9D, 0x34, 0x39, + 0x9B, 0xF5, 0xB1, 0x4B, 0x92, 0x0E, 0x34, 0xEF, + 0x38, 0xA7, 0xD0, 0x9F, 0xE6, 0x95, 0x93, 0x39, + 0x6E, 0x8F, 0xE7, 0x35, 0xE6, 0xF0, 0xA6, 0xAE, + 0x49, 0x90, 0x40, 0x10, 0x41, 0xD8, 0xA4, 0x06, + 0xB6, 0xFD, 0x86, 0xA1, 0x16, 0x1E, 0x45, 0xF9, + 0x5A, 0x3E, 0xAA, 0x5C, 0x10, 0x12, 0xE6, 0x66, + 0x2E, 0x44, 0xF1, 0x5F, 0x33, 0x5A, 0xC9, 0x71, + 0xE1, 0x76, 0x6B, 0x2B, 0xB9, 0xC9, 0x85, 0x10, + 0x99, 0x74, 0x14, 0x1B, 0x44, 0xD3, 0x7E, 0x1E, + 0x31, 0x98, 0x20, 0xA5, 0x5F, 0x02, 0x81, 0x81, + 0x00, 0xB2, 0x87, 0x12, 0x37, 0xBF, 0x9F, 0xAD, + 0x38, 0xC3, 0x31, 0x6A, 0xB7, 0x87, 0x7A, 0x6A, + 0x86, 0x80, 0x63, 0xE5, 0x42, 0xA7, 0x18, 0x6D, + 0x43, 0x1E, 0x8D, 0x27, 0xC1, 0x9A, 0xC0, 0x41, + 0x45, 0x84, 0x03, 0x39, 0x42, 0xE9, 0xFF, 0x6E, + 0x29, 0x73, 0xBB, 0x7B, 0x2D, 0x8B, 0x0E, 0x94, + 0xAD, 0x1E, 0xE8, 0x21, 0x58, 0x10, 0x8F, 0xBC, + 0x86, 0x64, 0x51, 0x7A, 0x5A, 0x46, 0x7F, 0xB9, + 0x63, 0x01, 0x4B, 0xD5, 0xDC, 0xC2, 0xB4, 0xFB, + 0x08, 0x7C, 0x23, 0x03, 0x9D, 0x11, 0x92, 0x0D, + 0xBE, 0x22, 0xFD, 0x9F, 0x16, 0xB4, 0xD8, 0x9E, + 0x23, 0x22, 0x5C, 0xD4, 0x55, 0xAD, 0xBA, 0xF3, + 0x2E, 0xF4, 0x3F, 0x18, 0x58, 0x64, 0xA3, 0x6D, + 0x63, 0x03, 0x09, 0xD6, 0x85, 0x3F, 0x77, 0x14, + 0xB3, 0x9A, 0xAE, 0x1E, 0xBE, 0xE3, 0x93, 0x8F, + 0x87, 0xC2, 0x70, 0x7E, 0x17, 0x8C, 0x73, 0x9F, + 0x9F, 0x02, 0x81, 0x81, 0x00, 0x96, 0x90, 0xBE, + 0xD1, 0x4B, 0x2A, 0xFA, 0xA2, 0x6D, 0x98, 0x6D, + 0x59, 0x22, 0x31, 0xEE, 0x27, 0xD7, 0x1D, 0x49, + 0x06, 0x5B, 0xD2, 0xBA, 0x1F, 0x78, 0x15, 0x7E, + 0x20, 0x22, 0x98, 0x81, 0xFD, 0x9D, 0x23, 0x22, + 0x7D, 0x0F, 0x84, 0x79, 0xEA, 0xEF, 0xA9, 0x22, + 0xFD, 0x75, 0xD5, 0xB1, 0x6B, 0x1A, 0x56, 0x1F, + 0xA6, 0x68, 0x0B, 0x04, 0x0C, 0xA0, 0xBD, 0xCE, + 0x65, 0x0B, 0x23, 0xB9, 0x17, 0xA4, 0xB1, 0xBB, + 0x79, 0x83, 0xA7, 0x4F, 0xAD, 0x70, 0xE1, 0xC3, + 0x05, 0xCB, 0xEC, 0x2B, 0xFF, 0x1A, 0x85, 0xA7, + 0x26, 0xA1, 0xD9, 0x02, 0x60, 0xE4, 0xF1, 0x08, + 0x4F, 0x51, 0x82, 0x34, 0xDC, 0xD3, 0xFE, 0x77, + 0x0B, 0x95, 0x20, 0x21, 0x5B, 0xD5, 0x43, 0xBB, + 0x6A, 0x41, 0x17, 0x71, 0x87, 0x54, 0x67, 0x6A, + 0x34, 0x17, 0x16, 0x66, 0xA7, 0x9F, 0x26, 0xE7, + 0x9C, 0x14, 0x9C, 0x5A, 0xA1, 0x02, 0x81, 0x81, + 0x00, 0xA0, 0xC9, 0x85, 0xA0, 0xA0, 0xA7, 0x91, + 0xA6, 0x59, 0xF9, 0x97, 0x31, 0x13, 0x4C, 0x44, + 0xF3, 0x7B, 0x2E, 0x52, 0x0A, 0x2C, 0xEA, 0x35, + 0x80, 0x0A, 0xD2, 0x72, 0x41, 0xED, 0x36, 0x0D, + 0xFD, 0xE6, 0xE8, 0xCA, 0x61, 0x4F, 0x12, 0x04, + 0x7F, 0xD0, 0x8B, 0x76, 0xAC, 0x4D, 0x13, 0xC0, + 0x56, 0xA0, 0x69, 0x9E, 0x2F, 0x98, 0xA1, 0xCA, + 0xC9, 0x10, 0x11, 0x29, 0x4D, 0x71, 0x20, 0x8F, + 0x4A, 0xBA, 0xB3, 0x3B, 0xA8, 0x7A, 0xA0, 0x51, + 0x7F, 0x41, 0x5B, 0xAC, 0xA8, 0x8D, 0x6B, 0xAC, + 0x00, 0x60, 0x88, 0xFA, 0x60, 0x1D, 0x34, 0x94, + 0x17, 0xE1, 0xF0, 0xC9, 0xB2, 0x3A, 0xFF, 0xA4, + 0xD4, 0x96, 0x61, 0x8D, 0xBC, 0x02, 0x49, 0x86, + 0xED, 0x69, 0x0B, 0xBB, 0x7B, 0x02, 0x57, 0x68, + 0xFF, 0x9D, 0xF8, 0xAC, 0x15, 0x41, 0x6F, 0x48, + 0x9F, 0x81, 0x29, 0xC3, 0x23, 0x41, 0xA8, 0xB4, + 0x4F + }; + struct byte_string key = {0}; + key.value = value; + key.size = ARRAY_LENGTH(value); + + struct key_value kv = {0}; + kv.key_material = &key; + + struct key_block kb = {0}; + kb.key_format_type = KMIP_KEYFORMAT_PKCS1; + kb.key_value = &kv; + kb.key_value_type = KMIP_TYPE_STRUCTURE; + kb.cryptographic_algorithm = KMIP_CRYPTOALG_RSA; + kb.cryptographic_length = 2048; + + struct private_key expected = {0}; + expected.key_block = &kb; + + struct private_key observed = {0}; + + int result = kmip_decode_private_key(&ctx, &observed); + result = report_decoding_test_result( + tracker, + &ctx, + kmip_compare_private_key(&expected, &observed), + result, + __func__); + kmip_free_private_key(&ctx, &observed); + kmip_destroy(&ctx); + return(result); +} + +int +test_encode_key_wrapping_specification(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 expected[136] = { + 0x42, 0x00, 0x47, 0x01, 0x00, 0x00, 0x00, 0x80, + 0x42, 0x00, 0x9E, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x36, 0x01, 0x00, 0x00, 0x00, 0x48, + 0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, + 0x66, 0x34, 0x62, 0x32, 0x62, 0x34, 0x63, 0x33, + 0x2D, 0x34, 0x63, 0x31, 0x39, 0x2D, 0x34, 0x65, + 0x63, 0x66, 0x2D, 0x38, 0x32, 0x37, 0x61, 0x2D, + 0x30, 0x31, 0x31, 0x63, 0x61, 0x36, 0x30, 0x35, + 0x37, 0x64, 0x33, 0x65, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x2B, 0x01, 0x00, 0x00, 0x00, 0x10, + 0x42, 0x00, 0x11, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x18, + 0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, + 0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x55, 0x73, + 0x61, 0x67, 0x65, 0x20, 0x4D, 0x61, 0x73, 0x6B + }; + + uint8 observed[136] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0); + + struct text_string uuid = {0}; + uuid.value = "f4b2b4c3-4c19-4ecf-827a-011ca6057d3e"; + uuid.size = 36; + + struct cryptographic_parameters cp = {0}; + cp.block_cipher_mode = KMIP_BLOCK_NIST_KEY_WRAP; + + struct encryption_key_information eki = {0}; + eki.unique_identifier = &uuid; + eki.cryptographic_parameters = &cp; + + struct text_string attribute_name = {0}; + attribute_name.value = "Cryptographic Usage Mask"; + attribute_name.size = 24; + + struct key_wrapping_specification kws = {0}; + kws.wrapping_method = KMIP_WRAP_ENCRYPT; + kws.encryption_key_info = &eki; + kws.attribute_names = &attribute_name; + kws.attribute_name_count = 1; + + int result = kmip_encode_key_wrapping_specification(&ctx, &kws); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_decode_key_wrapping_specification(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[136] = { + 0x42, 0x00, 0x47, 0x01, 0x00, 0x00, 0x00, 0x80, + 0x42, 0x00, 0x9E, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x36, 0x01, 0x00, 0x00, 0x00, 0x48, + 0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, + 0x66, 0x34, 0x62, 0x32, 0x62, 0x34, 0x63, 0x33, + 0x2D, 0x34, 0x63, 0x31, 0x39, 0x2D, 0x34, 0x65, + 0x63, 0x66, 0x2D, 0x38, 0x32, 0x37, 0x61, 0x2D, + 0x30, 0x31, 0x31, 0x63, 0x61, 0x36, 0x30, 0x35, + 0x37, 0x64, 0x33, 0x65, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x2B, 0x01, 0x00, 0x00, 0x00, 0x10, + 0x42, 0x00, 0x11, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x18, + 0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, + 0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x55, 0x73, + 0x61, 0x67, 0x65, 0x20, 0x4D, 0x61, 0x73, 0x6B + }; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0); + + struct text_string uuid = {0}; + uuid.value = "f4b2b4c3-4c19-4ecf-827a-011ca6057d3e"; + uuid.size = 36; + + struct cryptographic_parameters cp = {0}; + kmip_init_cryptographic_parameters(&cp); + + cp.block_cipher_mode = KMIP_BLOCK_NIST_KEY_WRAP; + + struct encryption_key_information eki = {0}; + eki.unique_identifier = &uuid; + eki.cryptographic_parameters = &cp; + + struct text_string attribute_name = {0}; + attribute_name.value = "Cryptographic Usage Mask"; + attribute_name.size = 24; + + struct key_wrapping_specification expected = {0}; + expected.wrapping_method = KMIP_WRAP_ENCRYPT; + expected.encryption_key_info = &eki; + expected.attribute_names = &attribute_name; + expected.attribute_name_count = 1; + + struct key_wrapping_specification observed = {0}; + + int result = kmip_decode_key_wrapping_specification(&ctx, &observed); + result = report_decoding_test_result( + tracker, + &ctx, + kmip_compare_key_wrapping_specification(&expected, &observed), + result, + __func__); + kmip_free_key_wrapping_specification(&ctx, &observed); + kmip_destroy(&ctx); + return(result); +} + +int +test_encode_create_request_payload(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + /* This encoding matches the following set of values: + * Request Payload + * Object Type - Symmetric Key + * Template Attribute + * Attribute + * Attribute Name - Cryptographic Algorithm + * Attribute Value - AES + * Attribute + * Attribute Name - Cryptographic Length + * Attribute Value - 128 + * Attribute + * Attribute Name - Cryptographic Usage Mask + * Attribute Value - Encrypt | Decrypt + */ + uint8 expected[200] = { + 0x42, 0x00, 0x79, 0x01, 0x00, 0x00, 0x00, 0xC0, + 0x42, 0x00, 0x57, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0xA8, + 0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30, + 0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x17, + 0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, + 0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x41, 0x6C, + 0x67, 0x6F, 0x72, 0x69, 0x74, 0x68, 0x6D, 0x00, + 0x42, 0x00, 0x0B, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30, + 0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x14, + 0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, + 0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x4C, 0x65, + 0x6E, 0x67, 0x74, 0x68, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x0B, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30, + 0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x18, + 0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, + 0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x55, 0x73, + 0x61, 0x67, 0x65, 0x20, 0x4D, 0x61, 0x73, 0x6B, + 0x42, 0x00, 0x0B, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[200] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0); + + struct attribute a[3] = {0}; + for(int i = 0; i < 3; i++) + { + kmip_init_attribute(&a[i]); + } + + enum cryptographic_algorithm algorithm = KMIP_CRYPTOALG_AES; + a[0].type = KMIP_ATTR_CRYPTOGRAPHIC_ALGORITHM; + a[0].value = &algorithm; + + int32 length = 128; + a[1].type = KMIP_ATTR_CRYPTOGRAPHIC_LENGTH; + a[1].value = &length; + + int32 mask = KMIP_CRYPTOMASK_ENCRYPT | KMIP_CRYPTOMASK_DECRYPT; + a[2].type = KMIP_ATTR_CRYPTOGRAPHIC_USAGE_MASK; + a[2].value = &mask; + + struct template_attribute ta = {0}; + ta.attributes = a; + ta.attribute_count = ARRAY_LENGTH(a); + + struct create_request_payload crp = {0}; + crp.object_type = KMIP_OBJTYPE_SYMMETRIC_KEY; + crp.template_attribute = &ta; + + int result = kmip_encode_create_request_payload(&ctx, &crp); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_encode_create_request_payload_kmip_2_0(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + /* This encoding matches the following set of values: + * Request Payload + * Object Type - Symmetric Key + * Attributes + * Cryptographic Algorithm - AES + * Cryptographic Length - 128 + * Cryptographic Usage Mask - Encrypt | Decrypt + * Protection Storage Masks + * Protection Storage Mask - Software | On System + * Protection Storage Mask - Off System | Off Premises + */ + uint8 expected[120] = { + 0x42, 0x00, 0x79, 0x01, 0x00, 0x00, 0x00, 0x70, + 0x42, 0x00, 0x57, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x01, 0x25, 0x01, 0x00, 0x00, 0x00, 0x30, + 0x42, 0x00, 0x28, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x2A, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x2C, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x01, 0x5F, 0x01, 0x00, 0x00, 0x00, 0x20, + 0x42, 0x01, 0x5E, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x01, 0x5E, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x02, 0x10, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[120] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_2_0); + + Attribute a[3] = {0}; + for(int i = 0; i < 3; i++) + { + kmip_init_attribute(&a[i]); + } + + enum cryptographic_algorithm algorithm = KMIP_CRYPTOALG_AES; + a[0].type = KMIP_ATTR_CRYPTOGRAPHIC_ALGORITHM; + a[0].value = &algorithm; + + int32 length = 128; + a[1].type = KMIP_ATTR_CRYPTOGRAPHIC_LENGTH; + a[1].value = &length; + + int32 mask = KMIP_CRYPTOMASK_ENCRYPT | KMIP_CRYPTOMASK_DECRYPT; + a[2].type = KMIP_ATTR_CRYPTOGRAPHIC_USAGE_MASK; + a[2].value = &mask; + + Attributes attributes = {0}; + LinkedList list = {0}; + LinkedListItem item_1, item_2, item_3 = {0}; + item_1.data = &a[0]; + item_2.data = &a[1]; + item_3.data = &a[2]; + kmip_linked_list_enqueue(&list, &item_1); + kmip_linked_list_enqueue(&list, &item_2); + kmip_linked_list_enqueue(&list, &item_3); + attributes.attribute_list = &list; + + ProtectionStorageMasks psm = {0}; + LinkedList masks = {0}; + LinkedListItem mask_1, mask_2 = {0}; + int32 m1 = KMIP_PROTECT_SOFTWARE | KMIP_PROTECT_ON_SYSTEM; + int32 m2 = KMIP_PROTECT_OFF_SYSTEM | KMIP_PROTECT_OFF_PREMISES; + mask_1.data = &m1; + mask_2.data = &m2; + kmip_linked_list_enqueue(&masks, &mask_1); + kmip_linked_list_enqueue(&masks, &mask_2); + psm.masks = &masks; + + CreateRequestPayload payload = {0}; + payload.object_type = KMIP_OBJTYPE_SYMMETRIC_KEY; + payload.attributes = &attributes; + payload.protection_storage_masks = &psm; + + int result = kmip_encode_create_request_payload(&ctx, &payload); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_decode_create_request_payload(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[200] = { + 0x42, 0x00, 0x79, 0x01, 0x00, 0x00, 0x00, 0xC0, + 0x42, 0x00, 0x57, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0xA8, + 0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30, + 0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x17, + 0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, + 0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x41, 0x6C, + 0x67, 0x6F, 0x72, 0x69, 0x74, 0x68, 0x6D, 0x00, + 0x42, 0x00, 0x0B, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30, + 0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x14, + 0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, + 0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x4C, 0x65, + 0x6E, 0x67, 0x74, 0x68, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x0B, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30, + 0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x18, + 0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, + 0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x55, 0x73, + 0x61, 0x67, 0x65, 0x20, 0x4D, 0x61, 0x73, 0x6B, + 0x42, 0x00, 0x0B, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00 + }; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0); + + struct attribute a[3] = {0}; + for(int i = 0; i < 3; i++) + { + kmip_init_attribute(&a[i]); + } + + enum cryptographic_algorithm algorithm = KMIP_CRYPTOALG_AES; + a[0].type = KMIP_ATTR_CRYPTOGRAPHIC_ALGORITHM; + a[0].value = &algorithm; + + int32 length = 128; + a[1].type = KMIP_ATTR_CRYPTOGRAPHIC_LENGTH; + a[1].value = &length; + + int32 mask = KMIP_CRYPTOMASK_ENCRYPT | KMIP_CRYPTOMASK_DECRYPT; + a[2].type = KMIP_ATTR_CRYPTOGRAPHIC_USAGE_MASK; + a[2].value = &mask; + + struct template_attribute ta = {0}; + ta.attributes = a; + ta.attribute_count = ARRAY_LENGTH(a); + + struct create_request_payload expected = {0}; + expected.object_type = KMIP_OBJTYPE_SYMMETRIC_KEY; + expected.template_attribute = &ta; + + struct create_request_payload observed = {0}; + + int result = kmip_decode_create_request_payload(&ctx, &observed); + result = report_decoding_test_result( + tracker, + &ctx, + kmip_compare_create_request_payload(&expected, &observed), + result, + __func__); + kmip_free_create_request_payload(&ctx, &observed); + kmip_destroy(&ctx); + return(result); +} + +int +test_decode_create_request_payload_kmip_2_0(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + /* This encoding matches the following set of values: + * Request Payload + * Object Type - Symmetric Key + * Attributes + * Cryptographic Algorithm - AES + * Cryptographic Length - 128 + * Cryptographic Usage Mask - Encrypt | Decrypt + * Protection Storage Masks + * Protection Storage Mask - Software | On System + * Protection Storage Mask - Off System | Off Premises + */ + uint8 encoding[120] = { + 0x42, 0x00, 0x79, 0x01, 0x00, 0x00, 0x00, 0x70, + 0x42, 0x00, 0x57, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x01, 0x25, 0x01, 0x00, 0x00, 0x00, 0x30, + 0x42, 0x00, 0x28, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x2A, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x2C, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x01, 0x5F, 0x01, 0x00, 0x00, 0x00, 0x20, + 0x42, 0x01, 0x5E, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x01, 0x5E, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x02, 0x10, 0x00, 0x00, 0x00, 0x00 + }; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_2_0); + + Attribute a[3] = {0}; + for(int i = 0; i < 3; i++) + { + kmip_init_attribute(&a[i]); + } + + enum cryptographic_algorithm algorithm = KMIP_CRYPTOALG_AES; + a[0].type = KMIP_ATTR_CRYPTOGRAPHIC_ALGORITHM; + a[0].value = &algorithm; + + int32 length = 128; + a[1].type = KMIP_ATTR_CRYPTOGRAPHIC_LENGTH; + a[1].value = &length; + + int32 mask = KMIP_CRYPTOMASK_ENCRYPT | KMIP_CRYPTOMASK_DECRYPT; + a[2].type = KMIP_ATTR_CRYPTOGRAPHIC_USAGE_MASK; + a[2].value = &mask; + + Attributes attributes = {0}; + LinkedList list = {0}; + LinkedListItem item_1, item_2, item_3 = {0}; + item_1.data = &a[0]; + item_2.data = &a[1]; + item_3.data = &a[2]; + kmip_linked_list_enqueue(&list, &item_1); + kmip_linked_list_enqueue(&list, &item_2); + kmip_linked_list_enqueue(&list, &item_3); + attributes.attribute_list = &list; + + ProtectionStorageMasks psm = {0}; + LinkedList masks = {0}; + LinkedListItem mask_1, mask_2 = {0}; + int32 m1 = KMIP_PROTECT_SOFTWARE | KMIP_PROTECT_ON_SYSTEM; + int32 m2 = KMIP_PROTECT_OFF_SYSTEM | KMIP_PROTECT_OFF_PREMISES; + mask_1.data = &m1; + mask_2.data = &m2; + kmip_linked_list_enqueue(&masks, &mask_1); + kmip_linked_list_enqueue(&masks, &mask_2); + psm.masks = &masks; + + CreateRequestPayload expected = {0}; + expected.object_type = KMIP_OBJTYPE_SYMMETRIC_KEY; + expected.attributes = &attributes; + expected.protection_storage_masks = &psm; + + CreateRequestPayload observed = {0}; + + int result = kmip_decode_create_request_payload(&ctx, &observed); + result = report_decoding_test_result( + tracker, + &ctx, + kmip_compare_create_request_payload(&expected, &observed), + result, + __func__); + kmip_free_create_request_payload(&ctx, &observed); + kmip_destroy(&ctx); + return(result); +} + +int +test_encode_create_response_payload(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 expected[72] = { + 0x42, 0x00, 0x7C, 0x01, 0x00, 0x00, 0x00, 0x40, + 0x42, 0x00, 0x57, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, + 0x66, 0x62, 0x34, 0x62, 0x35, 0x62, 0x39, 0x63, + 0x2D, 0x36, 0x31, 0x38, 0x38, 0x2D, 0x34, 0x63, + 0x36, 0x33, 0x2D, 0x38, 0x31, 0x34, 0x32, 0x2D, + 0x66, 0x65, 0x39, 0x63, 0x33, 0x32, 0x38, 0x31, + 0x32, 0x39, 0x66, 0x63, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[72] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0); + + struct text_string uuid = {0}; + uuid.value = "fb4b5b9c-6188-4c63-8142-fe9c328129fc"; + uuid.size = 36; + + struct create_response_payload crp = {0}; + crp.object_type = KMIP_OBJTYPE_SYMMETRIC_KEY; + crp.unique_identifier = &uuid; + + int result = kmip_encode_create_response_payload(&ctx, &crp); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_decode_create_response_payload(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[72] = { + 0x42, 0x00, 0x7C, 0x01, 0x00, 0x00, 0x00, 0x40, + 0x42, 0x00, 0x57, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, + 0x66, 0x62, 0x34, 0x62, 0x35, 0x62, 0x39, 0x63, + 0x2D, 0x36, 0x31, 0x38, 0x38, 0x2D, 0x34, 0x63, + 0x36, 0x33, 0x2D, 0x38, 0x31, 0x34, 0x32, 0x2D, + 0x66, 0x65, 0x39, 0x63, 0x33, 0x32, 0x38, 0x31, + 0x32, 0x39, 0x66, 0x63, 0x00, 0x00, 0x00, 0x00 + }; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0); + + struct text_string uuid = {0}; + uuid.value = "fb4b5b9c-6188-4c63-8142-fe9c328129fc"; + uuid.size = 36; + + struct create_response_payload expected = {0}; + expected.object_type = KMIP_OBJTYPE_SYMMETRIC_KEY; + expected.unique_identifier = &uuid; + + struct create_response_payload observed = {0}; + + int result = kmip_decode_create_response_payload(&ctx, &observed); + result = report_decoding_test_result( + tracker, + &ctx, + kmip_compare_create_response_payload(&expected, &observed), + result, + __func__); + kmip_free_create_response_payload(&ctx, &observed); + kmip_destroy(&ctx); + return(result); +} + +int +test_encode_create_response_payload_with_template_attribute(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 expected[136] = { + 0x42, 0x00, 0x7C, 0x01, 0x00, 0x00, 0x00, 0x80, + 0x42, 0x00, 0x57, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, + 0x66, 0x62, 0x34, 0x62, 0x35, 0x62, 0x39, 0x63, + 0x2D, 0x36, 0x31, 0x38, 0x38, 0x2D, 0x34, 0x63, + 0x36, 0x33, 0x2D, 0x38, 0x31, 0x34, 0x32, 0x2D, + 0x66, 0x65, 0x39, 0x63, 0x33, 0x32, 0x38, 0x31, + 0x32, 0x39, 0x66, 0x63, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x38, + 0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30, + 0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x17, + 0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, + 0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x41, 0x6C, + 0x67, 0x6F, 0x72, 0x69, 0x74, 0x68, 0x6D, 0x00, + 0x42, 0x00, 0x0B, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, + }; + + uint8 observed[136] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0); + + struct text_string uuid = {0}; + uuid.value = "fb4b5b9c-6188-4c63-8142-fe9c328129fc"; + uuid.size = 36; + + struct attribute a = {0}; + kmip_init_attribute(&a); + + enum cryptographic_algorithm algorithm = KMIP_CRYPTOALG_AES; + a.type = KMIP_ATTR_CRYPTOGRAPHIC_ALGORITHM; + a.value = &algorithm; + + struct template_attribute ta = {0}; + ta.attributes = &a; + ta.attribute_count = 1; + + struct create_response_payload crp = {0}; + crp.object_type = KMIP_OBJTYPE_SYMMETRIC_KEY; + crp.unique_identifier = &uuid; + crp.template_attribute = &ta; + + int result = kmip_encode_create_response_payload(&ctx, &crp); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_decode_create_response_payload_with_template_attribute(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[136] = { + 0x42, 0x00, 0x7C, 0x01, 0x00, 0x00, 0x00, 0x80, + 0x42, 0x00, 0x57, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, + 0x66, 0x62, 0x34, 0x62, 0x35, 0x62, 0x39, 0x63, + 0x2D, 0x36, 0x31, 0x38, 0x38, 0x2D, 0x34, 0x63, + 0x36, 0x33, 0x2D, 0x38, 0x31, 0x34, 0x32, 0x2D, + 0x66, 0x65, 0x39, 0x63, 0x33, 0x32, 0x38, 0x31, + 0x32, 0x39, 0x66, 0x63, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x38, + 0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30, + 0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x17, + 0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, + 0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x41, 0x6C, + 0x67, 0x6F, 0x72, 0x69, 0x74, 0x68, 0x6D, 0x00, + 0x42, 0x00, 0x0B, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, + }; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0); + + struct text_string uuid = {0}; + uuid.value = "fb4b5b9c-6188-4c63-8142-fe9c328129fc"; + uuid.size = 36; + + struct attribute a = {0}; + kmip_init_attribute(&a); + + enum cryptographic_algorithm algorithm = KMIP_CRYPTOALG_AES; + a.type = KMIP_ATTR_CRYPTOGRAPHIC_ALGORITHM; + a.value = &algorithm; + + struct template_attribute ta = {0}; + ta.attributes = &a; + ta.attribute_count = 1; + + struct create_response_payload expected = {0}; + expected.object_type = KMIP_OBJTYPE_SYMMETRIC_KEY; + expected.unique_identifier = &uuid; + expected.template_attribute = &ta; + + struct create_response_payload observed = {0}; + + int result = kmip_decode_create_response_payload(&ctx, &observed); + result = report_decoding_test_result( + tracker, + &ctx, + kmip_compare_create_response_payload(&expected, &observed), + result, + __func__); + kmip_free_create_response_payload(&ctx, &observed); + kmip_destroy(&ctx); + return(result); +} + +int +test_encode_get_request_payload(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 expected[56] = { + 0x42, 0x00, 0x79, 0x01, 0x00, 0x00, 0x00, 0x30, + 0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, + 0x34, 0x39, 0x61, 0x31, 0x63, 0x61, 0x38, 0x38, + 0x2D, 0x36, 0x62, 0x65, 0x61, 0x2D, 0x34, 0x66, + 0x62, 0x32, 0x2D, 0x62, 0x34, 0x35, 0x30, 0x2D, + 0x37, 0x65, 0x35, 0x38, 0x38, 0x30, 0x32, 0x63, + 0x33, 0x30, 0x33, 0x38, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[56] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0); + + struct text_string uuid = {0}; + uuid.value = "49a1ca88-6bea-4fb2-b450-7e58802c3038"; + uuid.size = 36; + + struct get_request_payload grp = {0}; + grp.unique_identifier = &uuid; + + int result = kmip_encode_get_request_payload(&ctx, &grp); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_decode_get_request_payload(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[56] = { + 0x42, 0x00, 0x79, 0x01, 0x00, 0x00, 0x00, 0x30, + 0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, + 0x34, 0x39, 0x61, 0x31, 0x63, 0x61, 0x38, 0x38, + 0x2D, 0x36, 0x62, 0x65, 0x61, 0x2D, 0x34, 0x66, + 0x62, 0x32, 0x2D, 0x62, 0x34, 0x35, 0x30, 0x2D, + 0x37, 0x65, 0x35, 0x38, 0x38, 0x30, 0x32, 0x63, + 0x33, 0x30, 0x33, 0x38, 0x00, 0x00, 0x00, 0x00 + }; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0); + + struct text_string uuid = {0}; + uuid.value = "49a1ca88-6bea-4fb2-b450-7e58802c3038"; + uuid.size = 36; + + struct get_request_payload expected = {0}; + expected.unique_identifier = &uuid; + + struct get_request_payload observed = {0}; + + int result = kmip_decode_get_request_payload(&ctx, &observed); + result = report_decoding_test_result( + tracker, + &ctx, + kmip_compare_get_request_payload(&expected, &observed), + result, + __func__); + kmip_free_get_request_payload(&ctx, &observed); + kmip_destroy(&ctx); + return(result); +} + +int +test_encode_get_request_payload_with_format_compression(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 expected[88] = { + 0x42, 0x00, 0x79, 0x01, 0x00, 0x00, 0x00, 0x50, + 0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, + 0x37, 0x63, 0x66, 0x35, 0x32, 0x30, 0x39, 0x62, + 0x2D, 0x36, 0x66, 0x66, 0x36, 0x2D, 0x34, 0x34, + 0x32, 0x36, 0x2D, 0x38, 0x39, 0x39, 0x65, 0x2D, + 0x32, 0x32, 0x62, 0x30, 0x36, 0x37, 0x38, 0x35, + 0x39, 0x33, 0x37, 0x32, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x42, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x41, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[88] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0); + + struct text_string uuid = {0}; + uuid.value = "7cf5209b-6ff6-4426-899e-22b067859372"; + uuid.size = 36; + + struct get_request_payload grp = {0}; + grp.unique_identifier = &uuid; + grp.key_format_type = KMIP_KEYFORMAT_PKCS1; + grp.key_compression_type = KMIP_KEYCOMP_EC_PUB_UNCOMPRESSED; + + int result = kmip_encode_get_request_payload(&ctx, &grp); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_encode_get_request_payload_with_wrapping_spec(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 expected[160] = { + 0x42, 0x00, 0x79, 0x01, 0x00, 0x00, 0x00, 0x98, + 0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, + 0x62, 0x66, 0x66, 0x37, 0x33, 0x34, 0x37, 0x62, + 0x2D, 0x33, 0x61, 0x33, 0x39, 0x2D, 0x34, 0x63, + 0x63, 0x62, 0x2D, 0x38, 0x32, 0x33, 0x34, 0x2D, + 0x62, 0x61, 0x32, 0x35, 0x36, 0x30, 0x63, 0x61, + 0x31, 0x35, 0x39, 0x38, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x47, 0x01, 0x00, 0x00, 0x00, 0x60, + 0x42, 0x00, 0x9E, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x36, 0x01, 0x00, 0x00, 0x00, 0x48, + 0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, + 0x31, 0x30, 0x30, 0x31, 0x38, 0x32, 0x64, 0x35, + 0x2D, 0x37, 0x32, 0x62, 0x38, 0x2D, 0x34, 0x37, + 0x61, 0x61, 0x2D, 0x38, 0x33, 0x38, 0x33, 0x2D, + 0x34, 0x64, 0x39, 0x37, 0x64, 0x35, 0x31, 0x32, + 0x65, 0x39, 0x38, 0x61, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x2B, 0x01, 0x00, 0x00, 0x00, 0x10, + 0x42, 0x00, 0x11, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[160] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0); + + struct text_string wrapping_uuid = {0}; + wrapping_uuid.value = "100182d5-72b8-47aa-8383-4d97d512e98a"; + wrapping_uuid.size = 36; + struct text_string uuid = {0}; + uuid.value = "bff7347b-3a39-4ccb-8234-ba2560ca1598"; + uuid.size = 36; + + struct cryptographic_parameters cp = {0}; + cp.block_cipher_mode = KMIP_BLOCK_NIST_KEY_WRAP; + + struct encryption_key_information eki = {0}; + eki.unique_identifier = &wrapping_uuid; + eki.cryptographic_parameters = &cp; + + struct key_wrapping_specification kws = {0}; + kws.wrapping_method = KMIP_WRAP_ENCRYPT; + kws.encryption_key_info = &eki; + + struct get_request_payload grp = {0}; + grp.unique_identifier = &uuid; + grp.key_wrapping_spec = &kws; + + int result = kmip_encode_get_request_payload(&ctx, &grp); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_encode_get_response_payload(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 expected[176] = { + 0x42, 0x00, 0x7C, 0x01, 0x00, 0x00, 0x00, 0xA8, + 0x42, 0x00, 0x57, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, + 0x34, 0x39, 0x61, 0x31, 0x63, 0x61, 0x38, 0x38, + 0x2D, 0x36, 0x62, 0x65, 0x61, 0x2D, 0x34, 0x66, + 0x62, 0x32, 0x2D, 0x62, 0x34, 0x35, 0x30, 0x2D, + 0x37, 0x65, 0x35, 0x38, 0x38, 0x30, 0x32, 0x63, + 0x33, 0x30, 0x33, 0x38, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x8F, 0x01, 0x00, 0x00, 0x00, 0x60, + 0x42, 0x00, 0x40, 0x01, 0x00, 0x00, 0x00, 0x58, + 0x42, 0x00, 0x42, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x45, 0x01, 0x00, 0x00, 0x00, 0x20, + 0x42, 0x00, 0x43, 0x08, 0x00, 0x00, 0x00, 0x18, + 0x73, 0x67, 0x57, 0x80, 0x51, 0x01, 0x2A, 0x6D, + 0x13, 0x4A, 0x85, 0x5E, 0x25, 0xC8, 0xCD, 0x5E, + 0x4C, 0xA1, 0x31, 0x45, 0x57, 0x29, 0xD3, 0xC8, + 0x42, 0x00, 0x28, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x2A, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0xA8, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[176] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0); + + struct text_string uuid = {0}; + uuid.value = "49a1ca88-6bea-4fb2-b450-7e58802c3038"; + uuid.size = 36; + + uint8 value[24] = { + 0x73, 0x67, 0x57, 0x80, 0x51, 0x01, 0x2A, 0x6D, + 0x13, 0x4A, 0x85, 0x5E, 0x25, 0xC8, 0xCD, 0x5E, + 0x4C, 0xA1, 0x31, 0x45, 0x57, 0x29, 0xD3, 0xC8 + }; + struct byte_string v = {0}; + v.value = value; + v.size = ARRAY_LENGTH(value); + + struct key_value kv = {0}; + kv.key_material = &v; + + struct key_block kb = {0}; + kb.key_format_type = KMIP_KEYFORMAT_RAW; + kb.key_value = &kv; + kb.cryptographic_algorithm = KMIP_CRYPTOALG_TRIPLE_DES; + kb.cryptographic_length = 168; + + struct symmetric_key key = {0}; + key.key_block = &kb; + + struct get_response_payload grp = {0}; + grp.object_type = KMIP_OBJTYPE_SYMMETRIC_KEY; + grp.unique_identifier = &uuid; + grp.object = &key; + + int result = kmip_encode_get_response_payload(&ctx, &grp); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_decode_get_response_payload(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[176] = { + 0x42, 0x00, 0x7C, 0x01, 0x00, 0x00, 0x00, 0xA8, + 0x42, 0x00, 0x57, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, + 0x34, 0x39, 0x61, 0x31, 0x63, 0x61, 0x38, 0x38, + 0x2D, 0x36, 0x62, 0x65, 0x61, 0x2D, 0x34, 0x66, + 0x62, 0x32, 0x2D, 0x62, 0x34, 0x35, 0x30, 0x2D, + 0x37, 0x65, 0x35, 0x38, 0x38, 0x30, 0x32, 0x63, + 0x33, 0x30, 0x33, 0x38, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x8F, 0x01, 0x00, 0x00, 0x00, 0x60, + 0x42, 0x00, 0x40, 0x01, 0x00, 0x00, 0x00, 0x58, + 0x42, 0x00, 0x42, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x45, 0x01, 0x00, 0x00, 0x00, 0x20, + 0x42, 0x00, 0x43, 0x08, 0x00, 0x00, 0x00, 0x18, + 0x73, 0x67, 0x57, 0x80, 0x51, 0x01, 0x2A, 0x6D, + 0x13, 0x4A, 0x85, 0x5E, 0x25, 0xC8, 0xCD, 0x5E, + 0x4C, 0xA1, 0x31, 0x45, 0x57, 0x29, 0xD3, 0xC8, + 0x42, 0x00, 0x28, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x2A, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0xA8, 0x00, 0x00, 0x00, 0x00 + }; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0); + + struct text_string uuid = {0}; + uuid.value = "49a1ca88-6bea-4fb2-b450-7e58802c3038"; + uuid.size = 36; + + uint8 value[24] = { + 0x73, 0x67, 0x57, 0x80, 0x51, 0x01, 0x2A, 0x6D, + 0x13, 0x4A, 0x85, 0x5E, 0x25, 0xC8, 0xCD, 0x5E, + 0x4C, 0xA1, 0x31, 0x45, 0x57, 0x29, 0xD3, 0xC8 + }; + struct byte_string v = {0}; + v.value = value; + v.size = ARRAY_LENGTH(value); + + struct key_value kv = {0}; + kv.key_material = &v; + + struct key_block kb = {0}; + kb.key_format_type = KMIP_KEYFORMAT_RAW; + kb.key_value = &kv; + kb.key_value_type = KMIP_TYPE_STRUCTURE; + kb.cryptographic_algorithm = KMIP_CRYPTOALG_TRIPLE_DES; + kb.cryptographic_length = 168; + + struct symmetric_key key = {0}; + key.key_block = &kb; + + struct get_response_payload expected = {0}; + expected.object_type = KMIP_OBJTYPE_SYMMETRIC_KEY; + expected.unique_identifier = &uuid; + expected.object = &key; + + struct get_response_payload observed = {0}; + + int result = kmip_decode_get_response_payload(&ctx, &observed); + result = report_decoding_test_result( + tracker, + &ctx, + kmip_compare_get_response_payload(&expected, &observed), + result, + __func__); + kmip_free_get_response_payload(&ctx, &observed); + kmip_destroy(&ctx); + return(result); +} + +int +test_encode_destroy_request_payload(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 expected[56] = { + 0x42, 0x00, 0x79, 0x01, 0x00, 0x00, 0x00, 0x30, + 0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, + 0x66, 0x62, 0x34, 0x62, 0x35, 0x62, 0x39, 0x63, + 0x2D, 0x36, 0x31, 0x38, 0x38, 0x2D, 0x34, 0x63, + 0x36, 0x33, 0x2D, 0x38, 0x31, 0x34, 0x32, 0x2D, + 0x66, 0x65, 0x39, 0x63, 0x33, 0x32, 0x38, 0x31, + 0x32, 0x39, 0x66, 0x63, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[56] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0); + + struct text_string uuid = {0}; + uuid.value = "fb4b5b9c-6188-4c63-8142-fe9c328129fc"; + uuid.size = 36; + + struct destroy_request_payload drp = {0}; + drp.unique_identifier = &uuid; + + int result = kmip_encode_destroy_request_payload(&ctx, &drp); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_decode_destroy_request_payload(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[56] = { + 0x42, 0x00, 0x79, 0x01, 0x00, 0x00, 0x00, 0x30, + 0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, + 0x66, 0x62, 0x34, 0x62, 0x35, 0x62, 0x39, 0x63, + 0x2D, 0x36, 0x31, 0x38, 0x38, 0x2D, 0x34, 0x63, + 0x36, 0x33, 0x2D, 0x38, 0x31, 0x34, 0x32, 0x2D, + 0x66, 0x65, 0x39, 0x63, 0x33, 0x32, 0x38, 0x31, + 0x32, 0x39, 0x66, 0x63, 0x00, 0x00, 0x00, 0x00 + }; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0); + + struct text_string uuid = {0}; + uuid.value = "fb4b5b9c-6188-4c63-8142-fe9c328129fc"; + uuid.size = 36; + + struct destroy_request_payload expected = {0}; + expected.unique_identifier = &uuid; + + struct destroy_request_payload observed = {0}; + + int result = kmip_decode_destroy_request_payload(&ctx, &observed); + result = report_decoding_test_result( + tracker, + &ctx, + kmip_compare_destroy_request_payload(&expected, &observed), + result, + __func__); + kmip_free_destroy_request_payload(&ctx, &observed); + kmip_destroy(&ctx); + return(result); +} + +int +test_encode_destroy_response_payload(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 expected[56] = { + 0x42, 0x00, 0x7C, 0x01, 0x00, 0x00, 0x00, 0x30, + 0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, + 0x66, 0x62, 0x34, 0x62, 0x35, 0x62, 0x39, 0x63, + 0x2D, 0x36, 0x31, 0x38, 0x38, 0x2D, 0x34, 0x63, + 0x36, 0x33, 0x2D, 0x38, 0x31, 0x34, 0x32, 0x2D, + 0x66, 0x65, 0x39, 0x63, 0x33, 0x32, 0x38, 0x31, + 0x32, 0x39, 0x66, 0x63, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[56] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0); + + struct text_string uuid = {0}; + uuid.value = "fb4b5b9c-6188-4c63-8142-fe9c328129fc"; + uuid.size = 36; + + struct destroy_response_payload drp = {0}; + drp.unique_identifier = &uuid; + + int result = kmip_encode_destroy_response_payload(&ctx, &drp); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_decode_destroy_response_payload(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[56] = { + 0x42, 0x00, 0x7C, 0x01, 0x00, 0x00, 0x00, 0x30, + 0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, + 0x66, 0x62, 0x34, 0x62, 0x35, 0x62, 0x39, 0x63, + 0x2D, 0x36, 0x31, 0x38, 0x38, 0x2D, 0x34, 0x63, + 0x36, 0x33, 0x2D, 0x38, 0x31, 0x34, 0x32, 0x2D, + 0x66, 0x65, 0x39, 0x63, 0x33, 0x32, 0x38, 0x31, + 0x32, 0x39, 0x66, 0x63, 0x00, 0x00, 0x00, 0x00 + }; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0); + + struct text_string uuid = {0}; + uuid.value = "fb4b5b9c-6188-4c63-8142-fe9c328129fc"; + uuid.size = 36; + + struct destroy_response_payload expected = {0}; + expected.unique_identifier = &uuid; + + struct destroy_response_payload observed = {0}; + + int result = kmip_decode_destroy_response_payload(&ctx, &observed); + result = report_decoding_test_result( + tracker, + &ctx, + kmip_compare_destroy_response_payload(&expected, &observed), + result, + __func__); + kmip_free_destroy_response_payload(&ctx, &observed); + kmip_destroy(&ctx); + return(result); +} + +int +test_encode_username_password_credential(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 expected[48] = { + 0x42, 0x00, 0x25, 0x01, 0x00, 0x00, 0x00, 0x28, + 0x42, 0x00, 0x99, 0x07, 0x00, 0x00, 0x00, 0x04, + 0x46, 0x72, 0x65, 0x64, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xA1, 0x07, 0x00, 0x00, 0x00, 0x09, + 0x70, 0x61, 0x73, 0x73, 0x77, 0x6F, 0x72, 0x64, + 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[48] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0); + + struct text_string username = {0}; + username.value = "Fred"; + username.size = 4; + struct text_string password = {0}; + password.value = "password1"; + password.size = 9; + + struct username_password_credential upc = {0}; + upc.username = &username; + upc.password = &password; + + int result = kmip_encode_username_password_credential(&ctx, &upc); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_decode_username_password_credential(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[48] = { + 0x42, 0x00, 0x25, 0x01, 0x00, 0x00, 0x00, 0x28, + 0x42, 0x00, 0x99, 0x07, 0x00, 0x00, 0x00, 0x04, + 0x46, 0x72, 0x65, 0x64, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xA1, 0x07, 0x00, 0x00, 0x00, 0x09, + 0x70, 0x61, 0x73, 0x73, 0x77, 0x6F, 0x72, 0x64, + 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 + }; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0); + + struct text_string username = {0}; + username.value = "Fred"; + username.size = 4; + struct text_string password = {0}; + password.value = "password1"; + password.size = 9; + + struct username_password_credential expected = {0}; + expected.username = &username; + expected.password = &password; + + struct username_password_credential observed = {0}; + + int result = kmip_decode_username_password_credential(&ctx, &observed); + result = report_decoding_test_result( + tracker, + &ctx, + kmip_compare_username_password_credential(&expected, &observed), + result, + __func__); + kmip_free_username_password_credential(&ctx, &observed); + kmip_destroy(&ctx); + return(result); +} + +int +test_encode_credential_username_password_credential(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 expected[64] = { + 0x42, 0x00, 0x23, 0x01, 0x00, 0x00, 0x00, 0x38, + 0x42, 0x00, 0x24, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x25, 0x01, 0x00, 0x00, 0x00, 0x20, + 0x42, 0x00, 0x99, 0x07, 0x00, 0x00, 0x00, 0x06, + 0x42, 0x61, 0x72, 0x6E, 0x65, 0x79, 0x00, 0x00, + 0x42, 0x00, 0xA1, 0x07, 0x00, 0x00, 0x00, 0x07, + 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x32, 0x00 + }; + + uint8 observed[64] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0); + + struct text_string username = {0}; + username.value = "Barney"; + username.size = 6; + struct text_string password = {0}; + password.value = "secret2"; + password.size = 7; + + struct username_password_credential upc = {0}; + upc.username = &username; + upc.password = &password; + + struct credential c = {0}; + c.credential_type = KMIP_CRED_USERNAME_AND_PASSWORD; + c.credential_value = &upc; + + int result = kmip_encode_credential(&ctx, &c); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_decode_credential_username_password_credential(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[64] = { + 0x42, 0x00, 0x23, 0x01, 0x00, 0x00, 0x00, 0x38, + 0x42, 0x00, 0x24, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x25, 0x01, 0x00, 0x00, 0x00, 0x20, + 0x42, 0x00, 0x99, 0x07, 0x00, 0x00, 0x00, 0x06, + 0x42, 0x61, 0x72, 0x6E, 0x65, 0x79, 0x00, 0x00, + 0x42, 0x00, 0xA1, 0x07, 0x00, 0x00, 0x00, 0x07, + 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x32, 0x00 + }; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0); + + struct text_string username = {0}; + username.value = "Barney"; + username.size = 6; + struct text_string password = {0}; + password.value = "secret2"; + password.size = 7; + + struct username_password_credential upc = {0}; + upc.username = &username; + upc.password = &password; + + struct credential expected = {0}; + expected.credential_type = KMIP_CRED_USERNAME_AND_PASSWORD; + expected.credential_value = &upc; + + struct credential observed = {0}; + + int result = kmip_decode_credential(&ctx, &observed); + result = report_decoding_test_result( + tracker, + &ctx, + kmip_compare_credential(&expected, &observed), + result, + __func__); + kmip_free_credential(&ctx, &observed); + kmip_destroy(&ctx); + return(result); +} + +int +test_encode_authentication_username_password_credential(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 expected[80] = { + 0x42, 0x00, 0x0C, 0x01, 0x00, 0x00, 0x00, 0x48, + 0x42, 0x00, 0x23, 0x01, 0x00, 0x00, 0x00, 0x40, + 0x42, 0x00, 0x24, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x25, 0x01, 0x00, 0x00, 0x00, 0x28, + 0x42, 0x00, 0x99, 0x07, 0x00, 0x00, 0x00, 0x04, + 0x46, 0x72, 0x65, 0x64, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xA1, 0x07, 0x00, 0x00, 0x00, 0x09, + 0x70, 0x61, 0x73, 0x73, 0x77, 0x6F, 0x72, 0x64, + 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[80] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0); + + struct text_string username = {0}; + username.value = "Fred"; + username.size = 4; + struct text_string password = {0}; + password.value = "password1"; + password.size = 9; + + struct username_password_credential upc = {0}; + upc.username = &username; + upc.password = &password; + + struct credential c = {0}; + c.credential_type = KMIP_CRED_USERNAME_AND_PASSWORD; + c.credential_value = &upc; + + struct authentication a = {0}; + a.credential = &c; + + int result = kmip_encode_authentication(&ctx, &a); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_decode_authentication_username_password_credential(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[80] = { + 0x42, 0x00, 0x0C, 0x01, 0x00, 0x00, 0x00, 0x48, + 0x42, 0x00, 0x23, 0x01, 0x00, 0x00, 0x00, 0x40, + 0x42, 0x00, 0x24, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x25, 0x01, 0x00, 0x00, 0x00, 0x28, + 0x42, 0x00, 0x99, 0x07, 0x00, 0x00, 0x00, 0x04, + 0x46, 0x72, 0x65, 0x64, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xA1, 0x07, 0x00, 0x00, 0x00, 0x09, + 0x70, 0x61, 0x73, 0x73, 0x77, 0x6F, 0x72, 0x64, + 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 + }; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0); + + struct text_string username = {0}; + username.value = "Fred"; + username.size = 4; + struct text_string password = {0}; + password.value = "password1"; + password.size = 9; + + struct username_password_credential upc = {0}; + upc.username = &username; + upc.password = &password; + + struct credential c = {0}; + c.credential_type = KMIP_CRED_USERNAME_AND_PASSWORD; + c.credential_value = &upc; + + struct authentication expected = {0}; + expected.credential = &c; + + struct authentication observed = {0}; + + int result = kmip_decode_authentication(&ctx, &observed); + result = report_decoding_test_result( + tracker, + &ctx, + kmip_compare_authentication(&expected, &observed), + result, + __func__); + kmip_free_authentication(&ctx, &observed); + kmip_destroy(&ctx); + return(result); +} + +int +test_encode_request_header(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 expected[168] = { + 0x42, 0x00, 0x77, 0x01, 0x00, 0x00, 0x00, 0xA0, + 0x42, 0x00, 0x69, 0x01, 0x00, 0x00, 0x00, 0x20, + 0x42, 0x00, 0x6A, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x6B, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x0C, 0x01, 0x00, 0x00, 0x00, 0x40, + 0x42, 0x00, 0x23, 0x01, 0x00, 0x00, 0x00, 0x38, + 0x42, 0x00, 0x24, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x25, 0x01, 0x00, 0x00, 0x00, 0x20, + 0x42, 0x00, 0x99, 0x07, 0x00, 0x00, 0x00, 0x06, + 0x42, 0x61, 0x72, 0x6E, 0x65, 0x79, 0x00, 0x00, + 0x42, 0x00, 0xA1, 0x07, 0x00, 0x00, 0x00, 0x07, + 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x32, 0x00, + 0x42, 0x00, 0x0E, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x10, 0x06, 0x00, 0x00, 0x00, 0x08, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, + 0x42, 0x00, 0x0D, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[168] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0); + + struct protocol_version pv = {0}; + pv.major = 1; + pv.minor = 0; + + struct text_string username = {0}; + username.value = "Barney"; + username.size = 6; + struct text_string password = {0}; + password.value = "secret2"; + password.size = 7; + + struct username_password_credential upc = {0}; + upc.username = &username; + upc.password = &password; + + struct credential c = {0}; + c.credential_type = KMIP_CRED_USERNAME_AND_PASSWORD; + c.credential_value = &upc; + + struct authentication a = {0}; + a.credential = &c; + + struct request_header rh = {0}; + kmip_init_request_header(&rh); + + rh.protocol_version = &pv; + rh.authentication = &a; + rh.batch_error_continuation_option = KMIP_BATCH_CONTINUE; + rh.batch_order_option = KMIP_TRUE; + rh.batch_count = 2; + + int result = kmip_encode_request_header(&ctx, &rh); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_decode_request_header(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[168] = { + 0x42, 0x00, 0x77, 0x01, 0x00, 0x00, 0x00, 0xA0, + 0x42, 0x00, 0x69, 0x01, 0x00, 0x00, 0x00, 0x20, + 0x42, 0x00, 0x6A, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x6B, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x0C, 0x01, 0x00, 0x00, 0x00, 0x40, + 0x42, 0x00, 0x23, 0x01, 0x00, 0x00, 0x00, 0x38, + 0x42, 0x00, 0x24, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x25, 0x01, 0x00, 0x00, 0x00, 0x20, + 0x42, 0x00, 0x99, 0x07, 0x00, 0x00, 0x00, 0x06, + 0x42, 0x61, 0x72, 0x6E, 0x65, 0x79, 0x00, 0x00, + 0x42, 0x00, 0xA1, 0x07, 0x00, 0x00, 0x00, 0x07, + 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x32, 0x00, + 0x42, 0x00, 0x0E, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x10, 0x06, 0x00, 0x00, 0x00, 0x08, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, + 0x42, 0x00, 0x0D, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00 + }; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0); + + struct protocol_version pv = {0}; + pv.major = 1; + pv.minor = 0; + + struct text_string username = {0}; + username.value = "Barney"; + username.size = 6; + struct text_string password = {0}; + password.value = "secret2"; + password.size = 7; + + struct username_password_credential upc = {0}; + upc.username = &username; + upc.password = &password; + + struct credential c = {0}; + c.credential_type = KMIP_CRED_USERNAME_AND_PASSWORD; + c.credential_value = &upc; + + struct authentication a = {0}; + a.credential = &c; + + struct request_header expected = {0}; + kmip_init_request_header(&expected); + + expected.protocol_version = &pv; + expected.authentication = &a; + expected.batch_error_continuation_option = KMIP_BATCH_CONTINUE; + expected.batch_order_option = KMIP_TRUE; + expected.batch_count = 2; + + struct request_header observed = {0}; + kmip_init_request_header(&observed); + + int result = kmip_decode_request_header(&ctx, &observed); + result = report_decoding_test_result( + tracker, + &ctx, + kmip_compare_request_header(&expected, &observed), + result, + __func__); + kmip_free_request_header(&ctx, &observed); + kmip_destroy(&ctx); + return(result); +} + +int +test_encode_response_header(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 expected[80] = { + 0x42, 0x00, 0x7A, 0x01, 0x00, 0x00, 0x00, 0x48, + 0x42, 0x00, 0x69, 0x01, 0x00, 0x00, 0x00, 0x20, + 0x42, 0x00, 0x6A, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x6B, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x92, 0x09, 0x00, 0x00, 0x00, 0x08, + 0x00, 0x00, 0x00, 0x00, 0x4F, 0x9A, 0x54, 0xE5, + 0x42, 0x00, 0x0D, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[80] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0); + + struct protocol_version pv = {0}; + pv.major = 1; + pv.minor = 0; + + struct response_header rh = {0}; + kmip_init_response_header(&rh); + + rh.protocol_version = &pv; + rh.time_stamp = 1335514341; + rh.batch_count = 1; + + int result = kmip_encode_response_header(&ctx, &rh); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_decode_response_header(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[80] = { + 0x42, 0x00, 0x7A, 0x01, 0x00, 0x00, 0x00, 0x48, + 0x42, 0x00, 0x69, 0x01, 0x00, 0x00, 0x00, 0x20, + 0x42, 0x00, 0x6A, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x6B, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x92, 0x09, 0x00, 0x00, 0x00, 0x08, + 0x00, 0x00, 0x00, 0x00, 0x4F, 0x9A, 0x54, 0xE5, + 0x42, 0x00, 0x0D, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00 + }; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0); + + struct protocol_version pv = {0}; + pv.major = 1; + pv.minor = 0; + + struct response_header expected = {0}; + kmip_init_response_header(&expected); + + expected.protocol_version = &pv; + expected.time_stamp = 1335514341; + expected.batch_count = 1; + + struct response_header observed = {0}; + kmip_init_response_header(&observed); + + int result = kmip_decode_response_header(&ctx, &observed); + result = report_decoding_test_result( + tracker, + &ctx, + kmip_compare_response_header(&expected, &observed), + result, + __func__); + kmip_free_response_header(&ctx, &observed); + kmip_destroy(&ctx); + return(result); +} + +int +test_encode_request_batch_item_get_payload(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 expected[80] = { + 0x42, 0x00, 0x0F, 0x01, 0x00, 0x00, 0x00, 0x48, + 0x42, 0x00, 0x5C, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x79, 0x01, 0x00, 0x00, 0x00, 0x30, + 0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, + 0x34, 0x39, 0x61, 0x31, 0x63, 0x61, 0x38, 0x38, + 0x2D, 0x36, 0x62, 0x65, 0x61, 0x2D, 0x34, 0x66, + 0x62, 0x32, 0x2D, 0x62, 0x34, 0x35, 0x30, 0x2D, + 0x37, 0x65, 0x35, 0x38, 0x38, 0x30, 0x32, 0x63, + 0x33, 0x30, 0x33, 0x38, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[80] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0); + + struct text_string uuid = {0}; + uuid.value = "49a1ca88-6bea-4fb2-b450-7e58802c3038"; + uuid.size = 36; + + struct get_request_payload grp = {0}; + grp.unique_identifier = &uuid; + + struct request_batch_item rbi = {0}; + kmip_init_request_batch_item(&rbi); + rbi.operation = KMIP_OP_GET; + rbi.request_payload = &grp; + + int result = kmip_encode_request_batch_item(&ctx, &rbi); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_encode_request_batch_item_get_payload_kmip_2_0(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + /* This encoding matches the following set of values: + * Batch Item + * Operation - Get + * Ephemeral - False + * Request Payload + * Unique Identifier - 49a1ca88-6bea-4fb2-b450-7e58802c3038 + */ + uint8 expected[96] = { + 0x42, 0x00, 0x0F, 0x01, 0x00, 0x00, 0x00, 0x58, + 0x42, 0x00, 0x5C, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x01, 0x54, 0x06, 0x00, 0x00, 0x00, 0x08, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x79, 0x01, 0x00, 0x00, 0x00, 0x30, + 0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, + 0x34, 0x39, 0x61, 0x31, 0x63, 0x61, 0x38, 0x38, + 0x2D, 0x36, 0x62, 0x65, 0x61, 0x2D, 0x34, 0x66, + 0x62, 0x32, 0x2D, 0x62, 0x34, 0x35, 0x30, 0x2D, + 0x37, 0x65, 0x35, 0x38, 0x38, 0x30, 0x32, 0x63, + 0x33, 0x30, 0x33, 0x38, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[96] = {0}; + KMIP ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_2_0); + + TextString uuid = {0}; + uuid.value = "49a1ca88-6bea-4fb2-b450-7e58802c3038"; + uuid.size = 36; + + GetRequestPayload grp = {0}; + grp.unique_identifier = &uuid; + + RequestBatchItem rbi = {0}; + kmip_init_request_batch_item(&rbi); + rbi.operation = KMIP_OP_GET; + rbi.ephemeral = KMIP_FALSE; + rbi.request_payload = &grp; + + int result = kmip_encode_request_batch_item(&ctx, &rbi); + result = report_encoding_test_result(tracker, &ctx, expected, observed, result, __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_decode_request_batch_item_get_payload(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[80] = { + 0x42, 0x00, 0x0F, 0x01, 0x00, 0x00, 0x00, 0x48, + 0x42, 0x00, 0x5C, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x79, 0x01, 0x00, 0x00, 0x00, 0x30, + 0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, + 0x34, 0x39, 0x61, 0x31, 0x63, 0x61, 0x38, 0x38, + 0x2D, 0x36, 0x62, 0x65, 0x61, 0x2D, 0x34, 0x66, + 0x62, 0x32, 0x2D, 0x62, 0x34, 0x35, 0x30, 0x2D, + 0x37, 0x65, 0x35, 0x38, 0x38, 0x30, 0x32, 0x63, + 0x33, 0x30, 0x33, 0x38, 0x00, 0x00, 0x00, 0x00 + }; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0); + + struct text_string uuid = {0}; + uuid.value = "49a1ca88-6bea-4fb2-b450-7e58802c3038"; + uuid.size = 36; + + struct get_request_payload grp = {0}; + grp.unique_identifier = &uuid; + + struct request_batch_item expected = {0}; + kmip_init_request_batch_item(&expected); + expected.operation = KMIP_OP_GET; + expected.request_payload = &grp; + + struct request_batch_item observed = {0}; + kmip_init_request_batch_item(&observed); + + int result = kmip_decode_request_batch_item(&ctx, &observed); + result = report_decoding_test_result( + tracker, + &ctx, + kmip_compare_request_batch_item(&expected, &observed), + result, + __func__); + kmip_free_request_batch_item(&ctx, &observed); + kmip_destroy(&ctx); + return(result); +} + +int +test_decode_request_batch_item_get_payload_kmip_2_0(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + /* This encoding matches the following set of values: + * Batch Item + * Operation - Get + * Ephemeral - False + * Request Payload + * Unique Identifier - 49a1ca88-6bea-4fb2-b450-7e58802c3038 + */ + uint8 encoding[96] = { + 0x42, 0x00, 0x0F, 0x01, 0x00, 0x00, 0x00, 0x58, + 0x42, 0x00, 0x5C, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x01, 0x54, 0x06, 0x00, 0x00, 0x00, 0x08, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x79, 0x01, 0x00, 0x00, 0x00, 0x30, + 0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, + 0x34, 0x39, 0x61, 0x31, 0x63, 0x61, 0x38, 0x38, + 0x2D, 0x36, 0x62, 0x65, 0x61, 0x2D, 0x34, 0x66, + 0x62, 0x32, 0x2D, 0x62, 0x34, 0x35, 0x30, 0x2D, + 0x37, 0x65, 0x35, 0x38, 0x38, 0x30, 0x32, 0x63, + 0x33, 0x30, 0x33, 0x38, 0x00, 0x00, 0x00, 0x00 + }; + + KMIP ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_2_0); + + TextString uuid = {0}; + uuid.value = "49a1ca88-6bea-4fb2-b450-7e58802c3038"; + uuid.size = 36; + + GetRequestPayload grp = {0}; + grp.unique_identifier = &uuid; + + RequestBatchItem expected = {0}; + kmip_init_request_batch_item(&expected); + expected.operation = KMIP_OP_GET; + expected.ephemeral = KMIP_FALSE; + expected.request_payload = &grp; + + RequestBatchItem observed = {0}; + kmip_init_request_batch_item(&observed); + + int result = kmip_decode_request_batch_item(&ctx, &observed); + int comparison = kmip_compare_request_batch_item(&expected, &observed); + if(!comparison) + { + kmip_print_request_batch_item(1, &expected); + kmip_print_request_batch_item(1, &observed); + } + result = report_decoding_test_result(tracker, &ctx, comparison, result, __func__); + + kmip_free_request_batch_item(&ctx, &observed); + kmip_destroy(&ctx); + return(result); +} + +int +test_encode_response_batch_item_get_payload(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 expected[216] = { + 0x42, 0x00, 0x0F, 0x01, 0x00, 0x00, 0x00, 0xD0, + 0x42, 0x00, 0x5C, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x7F, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x7C, 0x01, 0x00, 0x00, 0x00, 0xA8, + 0x42, 0x00, 0x57, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, + 0x34, 0x39, 0x61, 0x31, 0x63, 0x61, 0x38, 0x38, + 0x2D, 0x36, 0x62, 0x65, 0x61, 0x2D, 0x34, 0x66, + 0x62, 0x32, 0x2D, 0x62, 0x34, 0x35, 0x30, 0x2D, + 0x37, 0x65, 0x35, 0x38, 0x38, 0x30, 0x32, 0x63, + 0x33, 0x30, 0x33, 0x38, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x8F, 0x01, 0x00, 0x00, 0x00, 0x60, + 0x42, 0x00, 0x40, 0x01, 0x00, 0x00, 0x00, 0x58, + 0x42, 0x00, 0x42, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x45, 0x01, 0x00, 0x00, 0x00, 0x20, + 0x42, 0x00, 0x43, 0x08, 0x00, 0x00, 0x00, 0x18, + 0x73, 0x67, 0x57, 0x80, 0x51, 0x01, 0x2A, 0x6D, + 0x13, 0x4A, 0x85, 0x5E, 0x25, 0xC8, 0xCD, 0x5E, + 0x4C, 0xA1, 0x31, 0x45, 0x57, 0x29, 0xD3, 0xC8, + 0x42, 0x00, 0x28, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x2A, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0xA8, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[216] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0); + + struct text_string uuid = {0}; + uuid.value = "49a1ca88-6bea-4fb2-b450-7e58802c3038"; + uuid.size = 36; + + uint8 value[24] = { + 0x73, 0x67, 0x57, 0x80, 0x51, 0x01, 0x2A, 0x6D, + 0x13, 0x4A, 0x85, 0x5E, 0x25, 0xC8, 0xCD, 0x5E, + 0x4C, 0xA1, 0x31, 0x45, 0x57, 0x29, 0xD3, 0xC8 + }; + + struct byte_string v = {0}; + v.value = value; + v.size = ARRAY_LENGTH(value); + + struct key_value kv = {0}; + kv.key_material = &v; + + struct key_block kb = {0}; + kb.key_format_type = KMIP_KEYFORMAT_RAW; + kb.key_value = &kv; + kb.cryptographic_algorithm = KMIP_CRYPTOALG_TRIPLE_DES; + kb.cryptographic_length = 168; + + struct symmetric_key key = {0}; + key.key_block = &kb; + + struct get_response_payload grp = {0}; + grp.object_type = KMIP_OBJTYPE_SYMMETRIC_KEY; + grp.unique_identifier = &uuid; + grp.object = &key; + + struct response_batch_item rbi = {0}; + rbi.operation = KMIP_OP_GET; + rbi.result_status = KMIP_STATUS_SUCCESS; + rbi.response_payload = &grp; + + int result = kmip_encode_response_batch_item(&ctx, &rbi); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_decode_response_batch_item_get_payload(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[216] = { + 0x42, 0x00, 0x0F, 0x01, 0x00, 0x00, 0x00, 0xD0, + 0x42, 0x00, 0x5C, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x7F, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x7C, 0x01, 0x00, 0x00, 0x00, 0xA8, + 0x42, 0x00, 0x57, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, + 0x34, 0x39, 0x61, 0x31, 0x63, 0x61, 0x38, 0x38, + 0x2D, 0x36, 0x62, 0x65, 0x61, 0x2D, 0x34, 0x66, + 0x62, 0x32, 0x2D, 0x62, 0x34, 0x35, 0x30, 0x2D, + 0x37, 0x65, 0x35, 0x38, 0x38, 0x30, 0x32, 0x63, + 0x33, 0x30, 0x33, 0x38, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x8F, 0x01, 0x00, 0x00, 0x00, 0x60, + 0x42, 0x00, 0x40, 0x01, 0x00, 0x00, 0x00, 0x58, + 0x42, 0x00, 0x42, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x45, 0x01, 0x00, 0x00, 0x00, 0x20, + 0x42, 0x00, 0x43, 0x08, 0x00, 0x00, 0x00, 0x18, + 0x73, 0x67, 0x57, 0x80, 0x51, 0x01, 0x2A, 0x6D, + 0x13, 0x4A, 0x85, 0x5E, 0x25, 0xC8, 0xCD, 0x5E, + 0x4C, 0xA1, 0x31, 0x45, 0x57, 0x29, 0xD3, 0xC8, + 0x42, 0x00, 0x28, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x2A, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0xA8, 0x00, 0x00, 0x00, 0x00 + }; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0); + + struct text_string uuid = {0}; + uuid.value = "49a1ca88-6bea-4fb2-b450-7e58802c3038"; + uuid.size = 36; + + uint8 value[24] = { + 0x73, 0x67, 0x57, 0x80, 0x51, 0x01, 0x2A, 0x6D, + 0x13, 0x4A, 0x85, 0x5E, 0x25, 0xC8, 0xCD, 0x5E, + 0x4C, 0xA1, 0x31, 0x45, 0x57, 0x29, 0xD3, 0xC8 + }; + + struct byte_string v = {0}; + v.value = value; + v.size = ARRAY_LENGTH(value); + + struct key_value kv = {0}; + kv.key_material = &v; + + struct key_block kb = {0}; + kb.key_format_type = KMIP_KEYFORMAT_RAW; + kb.key_value = &kv; + kb.key_value_type = KMIP_TYPE_STRUCTURE; + kb.cryptographic_algorithm = KMIP_CRYPTOALG_TRIPLE_DES; + kb.cryptographic_length = 168; + + struct symmetric_key key = {0}; + key.key_block = &kb; + + struct get_response_payload grp = {0}; + grp.object_type = KMIP_OBJTYPE_SYMMETRIC_KEY; + grp.unique_identifier = &uuid; + grp.object = &key; + + struct response_batch_item expected = {0}; + expected.operation = KMIP_OP_GET; + expected.result_status = KMIP_STATUS_SUCCESS; + expected.response_payload = &grp; + + struct response_batch_item observed = {0}; + + int result = kmip_decode_response_batch_item(&ctx, &observed); + result = report_decoding_test_result( + tracker, + &ctx, + kmip_compare_response_batch_item(&expected, &observed), + result, + __func__); + kmip_free_response_batch_item(&ctx, &observed); + kmip_destroy(&ctx); + return(result); +} + +int +test_encode_request_message_get(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 expected[152] = { + 0x42, 0x00, 0x78, 0x01, 0x00, 0x00, 0x00, 0x90, + 0x42, 0x00, 0x77, 0x01, 0x00, 0x00, 0x00, 0x38, + 0x42, 0x00, 0x69, 0x01, 0x00, 0x00, 0x00, 0x20, + 0x42, 0x00, 0x6A, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x6B, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x0D, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x0F, 0x01, 0x00, 0x00, 0x00, 0x48, + 0x42, 0x00, 0x5C, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x79, 0x01, 0x00, 0x00, 0x00, 0x30, + 0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, + 0x34, 0x39, 0x61, 0x31, 0x63, 0x61, 0x38, 0x38, + 0x2D, 0x36, 0x62, 0x65, 0x61, 0x2D, 0x34, 0x66, + 0x62, 0x32, 0x2D, 0x62, 0x34, 0x35, 0x30, 0x2D, + 0x37, 0x65, 0x35, 0x38, 0x38, 0x30, 0x32, 0x63, + 0x33, 0x30, 0x33, 0x38, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[152] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0); + + struct protocol_version pv = {0}; + pv.major = 1; + pv.minor = 0; + + struct request_header rh = {0}; + kmip_init_request_header(&rh); + + rh.protocol_version = &pv; + rh.batch_count = 1; + + struct text_string uuid = {0}; + uuid.value = "49a1ca88-6bea-4fb2-b450-7e58802c3038"; + uuid.size = 36; + + struct get_request_payload grp = {0}; + grp.unique_identifier = &uuid; + + struct request_batch_item rbi = {0}; + kmip_init_request_batch_item(&rbi); + rbi.operation = KMIP_OP_GET; + rbi.request_payload = &grp; + + struct request_message rm = {0}; + rm.request_header = &rh; + rm.batch_items = &rbi; + rm.batch_count = 1; + + int result = kmip_encode_request_message(&ctx, &rm); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_decode_request_message_get(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[152] = { + 0x42, 0x00, 0x78, 0x01, 0x00, 0x00, 0x00, 0x90, + 0x42, 0x00, 0x77, 0x01, 0x00, 0x00, 0x00, 0x38, + 0x42, 0x00, 0x69, 0x01, 0x00, 0x00, 0x00, 0x20, + 0x42, 0x00, 0x6A, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x6B, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x0D, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x0F, 0x01, 0x00, 0x00, 0x00, 0x48, + 0x42, 0x00, 0x5C, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x79, 0x01, 0x00, 0x00, 0x00, 0x30, + 0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, + 0x34, 0x39, 0x61, 0x31, 0x63, 0x61, 0x38, 0x38, + 0x2D, 0x36, 0x62, 0x65, 0x61, 0x2D, 0x34, 0x66, + 0x62, 0x32, 0x2D, 0x62, 0x34, 0x35, 0x30, 0x2D, + 0x37, 0x65, 0x35, 0x38, 0x38, 0x30, 0x32, 0x63, + 0x33, 0x30, 0x33, 0x38, 0x00, 0x00, 0x00, 0x00 + }; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0); + + struct protocol_version pv = {0}; + pv.major = 1; + pv.minor = 0; + + struct request_header rh = {0}; + kmip_init_request_header(&rh); + + rh.protocol_version = &pv; + rh.batch_count = 1; + + struct text_string uuid = {0}; + uuid.value = "49a1ca88-6bea-4fb2-b450-7e58802c3038"; + uuid.size = 36; + + struct get_request_payload grp = {0}; + grp.unique_identifier = &uuid; + + struct request_batch_item rbi = {0}; + kmip_init_request_batch_item(&rbi); + rbi.operation = KMIP_OP_GET; + rbi.request_payload = &grp; + + struct request_message expected = {0}; + expected.request_header = &rh; + expected.batch_items = &rbi; + expected.batch_count = 1; + + struct request_message observed = {0}; + + int result = kmip_decode_request_message(&ctx, &observed); + int comparison = kmip_compare_request_message(&expected, &observed); + if(!comparison) + { + kmip_print_request_message(&expected); + kmip_print_request_message(&observed); + } + result = report_decoding_test_result(tracker, &ctx, comparison, result, __func__); + + kmip_free_request_message(&ctx, &observed); + kmip_destroy(&ctx); + return(result); +} + +int +test_encode_response_message_get(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 expected[304] = { + 0x42, 0x00, 0x7B, 0x01, 0x00, 0x00, 0x01, 0x28, + 0x42, 0x00, 0x7A, 0x01, 0x00, 0x00, 0x00, 0x48, + 0x42, 0x00, 0x69, 0x01, 0x00, 0x00, 0x00, 0x20, + 0x42, 0x00, 0x6A, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x6B, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x92, 0x09, 0x00, 0x00, 0x00, 0x08, + 0x00, 0x00, 0x00, 0x00, 0x4F, 0x9A, 0x54, 0xE7, + 0x42, 0x00, 0x0D, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x0F, 0x01, 0x00, 0x00, 0x00, 0xD0, + 0x42, 0x00, 0x5C, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x7F, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x7C, 0x01, 0x00, 0x00, 0x00, 0xA8, + 0x42, 0x00, 0x57, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, + 0x34, 0x39, 0x61, 0x31, 0x63, 0x61, 0x38, 0x38, + 0x2D, 0x36, 0x62, 0x65, 0x61, 0x2D, 0x34, 0x66, + 0x62, 0x32, 0x2D, 0x62, 0x34, 0x35, 0x30, 0x2D, + 0x37, 0x65, 0x35, 0x38, 0x38, 0x30, 0x32, 0x63, + 0x33, 0x30, 0x33, 0x38, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x8F, 0x01, 0x00, 0x00, 0x00, 0x60, + 0x42, 0x00, 0x40, 0x01, 0x00, 0x00, 0x00, 0x58, + 0x42, 0x00, 0x42, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x45, 0x01, 0x00, 0x00, 0x00, 0x20, + 0x42, 0x00, 0x43, 0x08, 0x00, 0x00, 0x00, 0x18, + 0x73, 0x67, 0x57, 0x80, 0x51, 0x01, 0x2A, 0x6D, + 0x13, 0x4A, 0x85, 0x5E, 0x25, 0xC8, 0xCD, 0x5E, + 0x4C, 0xA1, 0x31, 0x45, 0x57, 0x29, 0xD3, 0xC8, + 0x42, 0x00, 0x28, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x2A, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0xA8, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[304] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0); + + struct protocol_version pv = {0}; + pv.major = 1; + pv.minor = 0; + + struct response_header rh = {0}; + kmip_init_response_header(&rh); + + rh.protocol_version = &pv; + rh.time_stamp = 1335514343; + rh.batch_count = 1; + + struct text_string uuid = {0}; + uuid.value = "49a1ca88-6bea-4fb2-b450-7e58802c3038"; + uuid.size = 36; + + uint8 value[24] = { + 0x73, 0x67, 0x57, 0x80, 0x51, 0x01, 0x2A, 0x6D, + 0x13, 0x4A, 0x85, 0x5E, 0x25, 0xC8, 0xCD, 0x5E, + 0x4C, 0xA1, 0x31, 0x45, 0x57, 0x29, 0xD3, 0xC8 + }; + + struct byte_string v = {0}; + v.value = value; + v.size = ARRAY_LENGTH(value); + + struct key_value kv = {0}; + kv.key_material = &v; + + struct key_block kb = {0}; + kb.key_format_type = KMIP_KEYFORMAT_RAW; + kb.key_value = &kv; + kb.cryptographic_algorithm = KMIP_CRYPTOALG_TRIPLE_DES; + kb.cryptographic_length = 168; + + struct symmetric_key key = {0}; + key.key_block = &kb; + + struct get_response_payload grp = {0}; + grp.object_type = KMIP_OBJTYPE_SYMMETRIC_KEY; + grp.unique_identifier = &uuid; + grp.object = &key; + + struct response_batch_item rbi = {0}; + rbi.operation = KMIP_OP_GET; + rbi.result_status = KMIP_STATUS_SUCCESS; + rbi.response_payload = &grp; + + struct response_message rm = {0}; + rm.response_header = &rh; + rm.batch_items = &rbi; + rm.batch_count = 1; + + int result = kmip_encode_response_message(&ctx, &rm); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_decode_response_message_get(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[304] = { + 0x42, 0x00, 0x7B, 0x01, 0x00, 0x00, 0x01, 0x28, + 0x42, 0x00, 0x7A, 0x01, 0x00, 0x00, 0x00, 0x48, + 0x42, 0x00, 0x69, 0x01, 0x00, 0x00, 0x00, 0x20, + 0x42, 0x00, 0x6A, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x6B, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x92, 0x09, 0x00, 0x00, 0x00, 0x08, + 0x00, 0x00, 0x00, 0x00, 0x4F, 0x9A, 0x54, 0xE7, + 0x42, 0x00, 0x0D, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x0F, 0x01, 0x00, 0x00, 0x00, 0xD0, + 0x42, 0x00, 0x5C, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x7F, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x7C, 0x01, 0x00, 0x00, 0x00, 0xA8, + 0x42, 0x00, 0x57, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, + 0x34, 0x39, 0x61, 0x31, 0x63, 0x61, 0x38, 0x38, + 0x2D, 0x36, 0x62, 0x65, 0x61, 0x2D, 0x34, 0x66, + 0x62, 0x32, 0x2D, 0x62, 0x34, 0x35, 0x30, 0x2D, + 0x37, 0x65, 0x35, 0x38, 0x38, 0x30, 0x32, 0x63, + 0x33, 0x30, 0x33, 0x38, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x8F, 0x01, 0x00, 0x00, 0x00, 0x60, + 0x42, 0x00, 0x40, 0x01, 0x00, 0x00, 0x00, 0x58, + 0x42, 0x00, 0x42, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x45, 0x01, 0x00, 0x00, 0x00, 0x20, + 0x42, 0x00, 0x43, 0x08, 0x00, 0x00, 0x00, 0x18, + 0x73, 0x67, 0x57, 0x80, 0x51, 0x01, 0x2A, 0x6D, + 0x13, 0x4A, 0x85, 0x5E, 0x25, 0xC8, 0xCD, 0x5E, + 0x4C, 0xA1, 0x31, 0x45, 0x57, 0x29, 0xD3, 0xC8, + 0x42, 0x00, 0x28, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x2A, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0xA8, 0x00, 0x00, 0x00, 0x00 + }; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0); + + struct protocol_version pv = {0}; + pv.major = 1; + pv.minor = 0; + + struct response_header rh = {0}; + kmip_init_response_header(&rh); + + rh.protocol_version = &pv; + rh.time_stamp = 1335514343; + rh.batch_count = 1; + + struct text_string uuid = {0}; + uuid.value = "49a1ca88-6bea-4fb2-b450-7e58802c3038"; + uuid.size = 36; + + uint8 value[24] = { + 0x73, 0x67, 0x57, 0x80, 0x51, 0x01, 0x2A, 0x6D, + 0x13, 0x4A, 0x85, 0x5E, 0x25, 0xC8, 0xCD, 0x5E, + 0x4C, 0xA1, 0x31, 0x45, 0x57, 0x29, 0xD3, 0xC8 + }; + + struct byte_string v = {0}; + v.value = value; + v.size = ARRAY_LENGTH(value); + + struct key_value kv = {0}; + kv.key_material = &v; + + struct key_block kb = {0}; + kb.key_format_type = KMIP_KEYFORMAT_RAW; + kb.key_value = &kv; + kb.key_value_type = KMIP_TYPE_STRUCTURE; + kb.cryptographic_algorithm = KMIP_CRYPTOALG_TRIPLE_DES; + kb.cryptographic_length = 168; + + struct symmetric_key key = {0}; + key.key_block = &kb; + + struct get_response_payload grp = {0}; + grp.object_type = KMIP_OBJTYPE_SYMMETRIC_KEY; + grp.unique_identifier = &uuid; + grp.object = &key; + + struct response_batch_item rbi = {0}; + rbi.operation = KMIP_OP_GET; + rbi.result_status = KMIP_STATUS_SUCCESS; + rbi.response_payload = &grp; + + struct response_message expected = {0}; + expected.response_header = &rh; + expected.batch_items = &rbi; + expected.batch_count = 1; + + struct response_message observed = {0}; + + int result = kmip_decode_response_message(&ctx, &observed); + result = report_decoding_test_result( + tracker, + &ctx, + kmip_compare_response_message(&expected, &observed), + result, + __func__); + kmip_free_response_message(&ctx, &observed); + kmip_destroy(&ctx); + return(result); +} + +int +test_encode_attributes(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + /* This encoding matches the following set of values: + * Attributes + * Cryptographic Algorithm - AES + * Cryptographic Length - 128 + */ + uint8 expected[40] = { + 0x42, 0x01, 0x25, 0x01, 0x00, 0x00, 0x00, 0x20, + 0x42, 0x00, 0x28, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x2A, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[40] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_2_0); + + LinkedList attribute_list = {0}; + + LinkedListItem item_1 = {0}; + Attribute attr_1 = {0}; + kmip_init_attribute(&attr_1); + enum cryptographic_algorithm algorithm = KMIP_CRYPTOALG_AES; + attr_1.type = KMIP_ATTR_CRYPTOGRAPHIC_ALGORITHM; + attr_1.value = &algorithm; + item_1.data = &attr_1; + + LinkedListItem item_2 = {0}; + Attribute attr_2 = {0}; + kmip_init_attribute(&attr_2); + int32 length = 128; + attr_2.type = KMIP_ATTR_CRYPTOGRAPHIC_LENGTH; + attr_2.value = &length; + item_2.data = &attr_2; + + kmip_linked_list_enqueue(&attribute_list, &item_1); + kmip_linked_list_enqueue(&attribute_list, &item_2); + + Attributes attributes = {0}; + attributes.attribute_list = &attribute_list; + + int result = kmip_encode_attributes(&ctx, &attributes); + result = report_encoding_test_result(tracker, &ctx, expected, observed, result, __func__); + + kmip_destroy(&ctx); + + return(result); +} + +int +test_encode_attributes_with_invalid_kmip_version(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 observed[40] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_4); + + Attributes attributes = {0}; + + int result = kmip_encode_attributes(&ctx, &attributes); + kmip_destroy(&ctx); + + result = report_result(tracker, result, KMIP_INVALID_FOR_VERSION, __func__); + return(result); +} + +int +test_encode_attribute_v2_unique_identifier(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + /* This encoding matches the following value: + * Unique Identifier - fb4b5b9c-6188-4c63-8142-fe9c328129fc + */ + uint8 expected[48] = { + 0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, + 0x66, 0x62, 0x34, 0x62, 0x35, 0x62, 0x39, 0x63, + 0x2D, 0x36, 0x31, 0x38, 0x38, 0x2D, 0x34, 0x63, + 0x36, 0x33, 0x2D, 0x38, 0x31, 0x34, 0x32, 0x2D, + 0x66, 0x65, 0x39, 0x63, 0x33, 0x32, 0x38, 0x31, + 0x32, 0x39, 0x66, 0x63, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[48] = {0}; + KMIP ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_2_0); + + Attribute attribute = {0}; + kmip_init_attribute(&attribute); + TextString unique_identifier = {0}; + unique_identifier.value = "fb4b5b9c-6188-4c63-8142-fe9c328129fc"; + unique_identifier.size = 36; + attribute.type = KMIP_ATTR_UNIQUE_IDENTIFIER; + attribute.value = &unique_identifier; + + int result = kmip_encode_attribute_v2(&ctx, &attribute); + result = report_encoding_test_result(tracker, &ctx, expected, observed, result, __func__); + + kmip_destroy(&ctx); + + return(result); +} + +int +test_encode_attribute_v2_name(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + /* This encoding matches the following value: + * Name + * Value - Template1 + * Type - Uninterpreted Text String + */ + uint8 expected[48] = { + 0x42, 0x00, 0x53, 0x01, 0x00, 0x00, 0x00, 0x28, + 0x42, 0x00, 0x55, 0x07, 0x00, 0x00, 0x00, 0x09, + 0x54, 0x65, 0x6D, 0x70, 0x6C, 0x61, 0x74, 0x65, + 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x54, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[48] = {0}; + KMIP ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_2_0); + + Attribute attribute = {0}; + kmip_init_attribute(&attribute); + TextString name_value = {0}; + name_value.value = "Template1"; + name_value.size = 9; + Name name = {0}; + name.value = &name_value; + name.type = KMIP_NAME_UNINTERPRETED_TEXT_STRING; + + attribute.type = KMIP_ATTR_NAME; + attribute.value = &name; + + int result = kmip_encode_attribute_v2(&ctx, &attribute); + result = report_encoding_test_result(tracker, &ctx, expected, observed, result, __func__); + + kmip_destroy(&ctx); + + return(result); +} + +int +test_encode_attribute_v2_object_type(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + /* This encoding matches the following value: + * Object Type - Symmetric Key + */ + uint8 expected[16] = { + 0x42, 0x00, 0x57, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[16] = {0}; + KMIP ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_2_0); + + Attribute attribute = {0}; + kmip_init_attribute(&attribute); + enum object_type object_type = KMIP_OBJTYPE_SYMMETRIC_KEY; + attribute.type = KMIP_ATTR_OBJECT_TYPE; + attribute.value = &object_type; + + int result = kmip_encode_attribute_v2(&ctx, &attribute); + result = report_encoding_test_result(tracker, &ctx, expected, observed, result, __func__); + + kmip_destroy(&ctx); + + return(result); +} + +int +test_encode_attribute_v2_cryptographic_algorithm(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + /* This encoding matches the following value: + * Cryptographic Algorithm - AES + */ + uint8 expected[16] = { + 0x42, 0x00, 0x28, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[16] = {0}; + KMIP ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_2_0); + + Attribute attribute = {0}; + kmip_init_attribute(&attribute); + enum cryptographic_algorithm algorithm = KMIP_CRYPTOALG_AES; + attribute.type = KMIP_ATTR_CRYPTOGRAPHIC_ALGORITHM; + attribute.value = &algorithm; + + int result = kmip_encode_attribute_v2(&ctx, &attribute); + result = report_encoding_test_result(tracker, &ctx, expected, observed, result, __func__); + + kmip_destroy(&ctx); + + return(result); +} + +int +test_encode_attribute_v2_cryptographic_length(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + /* This encoding matches the following value: + * Cryptographic Length - 128 + */ + uint8 expected[16] = { + 0x42, 0x00, 0x2A, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[16] = {0}; + KMIP ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_2_0); + + Attribute attribute = {0}; + kmip_init_attribute(&attribute); + int32 length = 128; + attribute.type = KMIP_ATTR_CRYPTOGRAPHIC_LENGTH; + attribute.value = &length; + + int result = kmip_encode_attribute_v2(&ctx, &attribute); + result = report_encoding_test_result(tracker, &ctx, expected, observed, result, __func__); + + kmip_destroy(&ctx); + + return(result); +} + +int +test_encode_attribute_v2_cryptographic_usage_mask(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + /* This encoding matches the following value: + * Cryptographic Usage Mask - Encrypt | Decrypt + */ + uint8 expected[16] = { + 0x42, 0x00, 0x2C, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[16] = {0}; + KMIP ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_2_0); + + Attribute attribute = {0}; + kmip_init_attribute(&attribute); + int32 mask = KMIP_CRYPTOMASK_ENCRYPT | KMIP_CRYPTOMASK_DECRYPT; + attribute.type = KMIP_ATTR_CRYPTOGRAPHIC_USAGE_MASK; + attribute.value = &mask; + + int result = kmip_encode_attribute_v2(&ctx, &attribute); + result = report_encoding_test_result(tracker, &ctx, expected, observed, result, __func__); + + kmip_destroy(&ctx); + + return(result); +} + +int +test_encode_attribute_v2_state(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + /* This encoding matches the following value: + * State - Active + */ + uint8 expected[16] = { + 0x42, 0x00, 0x8D, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[16] = {0}; + KMIP ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_2_0); + + Attribute attribute = {0}; + kmip_init_attribute(&attribute); + enum state state = KMIP_STATE_ACTIVE; + attribute.type = KMIP_ATTR_STATE; + attribute.value = &state; + + int result = kmip_encode_attribute_v2(&ctx, &attribute); + result = report_encoding_test_result(tracker, &ctx, expected, observed, result, __func__); + + kmip_destroy(&ctx); + + return(result); +} + +int +test_encode_attribute_v2_unsupported_attribute(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[16] = {0}; + + KMIP ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_2_0); + + Attribute attribute = {0}; + attribute.type = -1; + int result = kmip_encode_attribute_v2(&ctx, &attribute); + if(result != KMIP_ERROR_ATTR_UNSUPPORTED) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + kmip_destroy(&ctx); + + TEST_PASSED(tracker, __func__); +} + +int +test_decode_attributes(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + /* This encoding matches the following set of values: + * Attributes + * Cryptographic Algorithm - AES + * Cryptographic Length - 128 + */ + uint8 encoding[40] = { + 0x42, 0x01, 0x25, 0x01, 0x00, 0x00, 0x00, 0x20, + 0x42, 0x00, 0x28, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x2A, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00 + }; + + KMIP ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_2_0); + + LinkedList attribute_list = {0}; + + LinkedListItem item_1 = {0}; + Attribute attr_1 = {0}; + kmip_init_attribute(&attr_1); + enum cryptographic_algorithm algorithm = KMIP_CRYPTOALG_AES; + attr_1.type = KMIP_ATTR_CRYPTOGRAPHIC_ALGORITHM; + attr_1.value = &algorithm; + item_1.data = &attr_1; + + LinkedListItem item_2 = {0}; + Attribute attr_2 = {0}; + kmip_init_attribute(&attr_2); + int32 length = 128; + attr_2.type = KMIP_ATTR_CRYPTOGRAPHIC_LENGTH; + attr_2.value = &length; + item_2.data = &attr_2; + + kmip_linked_list_enqueue(&attribute_list, &item_1); + kmip_linked_list_enqueue(&attribute_list, &item_2); + + Attributes expected = {0}; + expected.attribute_list = &attribute_list; + + Attributes observed = {0}; + int result = kmip_decode_attributes(&ctx, &observed); + int comparison = kmip_compare_attributes(&expected, &observed); + if(!comparison) + { + kmip_print_attributes(1, &expected); + kmip_print_attributes(1, &observed); + } + result = report_decoding_test_result(tracker, &ctx, comparison, result, __func__); + + kmip_free_attributes(&ctx, &observed); + kmip_destroy(&ctx); + + return(result); +} + +int +test_decode_attributes_with_invalid_kmip_version(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[] = {0}; + + KMIP ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_4); + + Attributes observed = {0}; + int result = kmip_decode_attributes(&ctx, &observed); + + kmip_free_attributes(&ctx, &observed); + kmip_destroy(&ctx); + + result = report_result(tracker, result, KMIP_INVALID_FOR_VERSION, __func__); + return(result); +} + +int +test_decode_attribute_v2_unique_identifier(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + /* This encoding matches the following value: + * Unique Identifier - fb4b5b9c-6188-4c63-8142-fe9c328129fc + */ + uint8 encoding[48] = { + 0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, + 0x66, 0x62, 0x34, 0x62, 0x35, 0x62, 0x39, 0x63, + 0x2D, 0x36, 0x31, 0x38, 0x38, 0x2D, 0x34, 0x63, + 0x36, 0x33, 0x2D, 0x38, 0x31, 0x34, 0x32, 0x2D, + 0x66, 0x65, 0x39, 0x63, 0x33, 0x32, 0x38, 0x31, + 0x32, 0x39, 0x66, 0x63, 0x00, 0x00, 0x00, 0x00 + }; + + KMIP ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_2_0); + + Attribute expected = {0}; + kmip_init_attribute(&expected); + TextString unique_identifier = {0}; + unique_identifier.value = "fb4b5b9c-6188-4c63-8142-fe9c328129fc"; + unique_identifier.size = 36; + expected.type = KMIP_ATTR_UNIQUE_IDENTIFIER; + expected.value = &unique_identifier; + + Attribute observed = {0}; + int result = kmip_decode_attribute_v2(&ctx, &observed); + int comparison = kmip_compare_attribute(&expected, &observed); + if(!comparison) + { + kmip_print_attribute(1, &expected); + kmip_print_attribute(1, &observed); + } + result = report_decoding_test_result(tracker, &ctx, comparison, result, __func__); + + kmip_free_attribute(&ctx, &observed); + kmip_destroy(&ctx); + + return(result); +} + +int +test_decode_attribute_v2_name(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + /* This encoding matches the following value: + * Name + * Value - Template1 + * Type - Uninterpreted Text String + */ + uint8 encoding[48] = { + 0x42, 0x00, 0x53, 0x01, 0x00, 0x00, 0x00, 0x28, + 0x42, 0x00, 0x55, 0x07, 0x00, 0x00, 0x00, 0x09, + 0x54, 0x65, 0x6D, 0x70, 0x6C, 0x61, 0x74, 0x65, + 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x54, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00 + }; + + KMIP ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_2_0); + + Attribute expected = {0}; + kmip_init_attribute(&expected); + TextString name_value = {0}; + name_value.value = "Template1"; + name_value.size = 9; + Name name = {0}; + name.value = &name_value; + name.type = KMIP_NAME_UNINTERPRETED_TEXT_STRING; + + expected.type = KMIP_ATTR_NAME; + expected.value = &name; + + Attribute observed = {0}; + int result = kmip_decode_attribute_v2(&ctx, &observed); + int comparison = kmip_compare_attribute(&expected, &observed); + if(!comparison) + { + kmip_print_attribute(1, &expected); + kmip_print_attribute(1, &observed); + } + result = report_decoding_test_result(tracker, &ctx, comparison, result, __func__); + + kmip_free_attribute(&ctx, &observed); + kmip_destroy(&ctx); + + return(result); +} + +int +test_decode_attribute_v2_object_type(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + /* This encoding matches the following value: + * Object Type - Symmetric Key + */ + uint8 encoding[16] = { + 0x42, 0x00, 0x57, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00 + }; + + KMIP ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_2_0); + + Attribute expected = {0}; + kmip_init_attribute(&expected); + enum object_type object_type = KMIP_OBJTYPE_SYMMETRIC_KEY; + expected.type = KMIP_ATTR_OBJECT_TYPE; + expected.value = &object_type; + + Attribute observed = {0}; + int result = kmip_decode_attribute_v2(&ctx, &observed); + int comparison = kmip_compare_attribute(&expected, &observed); + if(!comparison) + { + kmip_print_attribute(1, &expected); + kmip_print_attribute(1, &observed); + } + result = report_decoding_test_result(tracker, &ctx, comparison, result, __func__); + + kmip_free_attribute(&ctx, &observed); + kmip_destroy(&ctx); + + return(result); +} + +int +test_decode_attribute_v2_cryptographic_algorithm(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + /* This encoding matches the following value: + * Cryptographic Algorithm - AES + */ + uint8 encoding[16] = { + 0x42, 0x00, 0x28, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00 + }; + + KMIP ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_2_0); + + Attribute expected = {0}; + kmip_init_attribute(&expected); + enum cryptographic_algorithm algorithm = KMIP_CRYPTOALG_AES; + expected.type = KMIP_ATTR_CRYPTOGRAPHIC_ALGORITHM; + expected.value = &algorithm; + + Attribute observed = {0}; + int result = kmip_decode_attribute_v2(&ctx, &observed); + int comparison = kmip_compare_attribute(&expected, &observed); + if(!comparison) + { + kmip_print_attribute(1, &expected); + kmip_print_attribute(1, &observed); + } + result = report_decoding_test_result(tracker, &ctx, comparison, result, __func__); + + kmip_free_attribute(&ctx, &observed); + kmip_destroy(&ctx); + + return(result); +} + +int +test_decode_attribute_v2_cryptographic_length(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + /* This encoding matches the following value: + * Cryptographic Length - 128 + */ + uint8 encoding[16] = { + 0x42, 0x00, 0x2A, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00 + }; + + KMIP ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_2_0); + + Attribute expected = {0}; + kmip_init_attribute(&expected); + int32 length = 128; + expected.type = KMIP_ATTR_CRYPTOGRAPHIC_LENGTH; + expected.value = &length; + + Attribute observed = {0}; + int result = kmip_decode_attribute_v2(&ctx, &observed); + int comparison = kmip_compare_attribute(&expected, &observed); + if(!comparison) + { + kmip_print_attribute(1, &expected); + kmip_print_attribute(1, &observed); + } + result = report_decoding_test_result(tracker, &ctx, comparison, result, __func__); + + kmip_free_attribute(&ctx, &observed); + kmip_destroy(&ctx); + + return(result); +} + +int +test_decode_attribute_v2_cryptographic_usage_mask(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + /* This encoding matches the following value: + * Cryptographic Usage Mask - Encrypt | Decrypt + */ + uint8 encoding[16] = { + 0x42, 0x00, 0x2C, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00 + }; + + KMIP ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_2_0); + + Attribute expected = {0}; + kmip_init_attribute(&expected); + int32 mask = KMIP_CRYPTOMASK_ENCRYPT | KMIP_CRYPTOMASK_DECRYPT; + expected.type = KMIP_ATTR_CRYPTOGRAPHIC_USAGE_MASK; + expected.value = &mask; + + Attribute observed = {0}; + int result = kmip_decode_attribute_v2(&ctx, &observed); + int comparison = kmip_compare_attribute(&expected, &observed); + if(!comparison) + { + kmip_print_attribute(1, &expected); + kmip_print_attribute(1, &observed); + } + result = report_decoding_test_result(tracker, &ctx, comparison, result, __func__); + + kmip_free_attribute(&ctx, &observed); + kmip_destroy(&ctx); + + return(result); +} + +int +test_decode_attribute_v2_state(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + /* This encoding matches the following value: + * State - Active + */ + uint8 encoding[16] = { + 0x42, 0x00, 0x8D, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00 + }; + + KMIP ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_2_0); + + Attribute expected = {0}; + kmip_init_attribute(&expected); + enum state state = KMIP_STATE_ACTIVE; + expected.type = KMIP_ATTR_STATE; + expected.value = &state; + + Attribute observed = {0}; + int result = kmip_decode_attribute_v2(&ctx, &observed); + int comparison = kmip_compare_attribute(&expected, &observed); + if(!comparison) + { + kmip_print_attribute(1, &expected); + kmip_print_attribute(1, &observed); + } + result = report_decoding_test_result(tracker, &ctx, comparison, result, __func__); + + kmip_free_attribute(&ctx, &observed); + kmip_destroy(&ctx); + + return(result); +} + +int +test_decode_attribute_v2_unsupported_attribute(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[3] = {0x42, 0x00, 0x00}; + + KMIP ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_2_0); + + Attribute observed = {0}; + int result = kmip_decode_attribute_v2(&ctx, &observed); + if(result != KMIP_ERROR_ATTR_UNSUPPORTED) + { + TEST_FAILED(tracker, __func__, __LINE__); + } + + kmip_free_attribute(&ctx, &observed); + kmip_destroy(&ctx); + + TEST_PASSED(tracker, __func__); +} + +int +test_encode_template_attribute(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 expected[288] = { + 0x42, 0x00, 0x91, 0x01, 0x00, 0x00, 0x01, 0x18, + 0x42, 0x00, 0x53, 0x01, 0x00, 0x00, 0x00, 0x28, + 0x42, 0x00, 0x55, 0x07, 0x00, 0x00, 0x00, 0x09, + 0x54, 0x65, 0x6D, 0x70, 0x6C, 0x61, 0x74, 0x65, + 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x54, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30, + 0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x17, + 0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, + 0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x41, 0x6C, + 0x67, 0x6F, 0x72, 0x69, 0x74, 0x68, 0x6D, 0x00, + 0x42, 0x00, 0x0B, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30, + 0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x14, + 0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, + 0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x4C, 0x65, + 0x6E, 0x67, 0x74, 0x68, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x0B, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30, + 0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x18, + 0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, + 0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x55, 0x73, + 0x61, 0x67, 0x65, 0x20, 0x4D, 0x61, 0x73, 0x6B, + 0x42, 0x00, 0x0B, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x38, + 0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x04, + 0x4E, 0x61, 0x6D, 0x65, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x0B, 0x01, 0x00, 0x00, 0x00, 0x20, + 0x42, 0x00, 0x55, 0x07, 0x00, 0x00, 0x00, 0x04, + 0x4B, 0x65, 0x79, 0x31, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x54, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[288] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0); + + struct text_string v = {0}; + v.value = "Template1"; + v.size = 9; + + struct name n = {0}; + n.value = &v; + n.type = KMIP_NAME_UNINTERPRETED_TEXT_STRING; + + struct attribute a[4] = {0}; + for(int i = 0; i < 4; i++) + { + kmip_init_attribute(&a[i]); + } + + enum cryptographic_algorithm algorithm = KMIP_CRYPTOALG_AES; + a[0].type = KMIP_ATTR_CRYPTOGRAPHIC_ALGORITHM; + a[0].value = &algorithm; + + int32 length = 128; + a[1].type = KMIP_ATTR_CRYPTOGRAPHIC_LENGTH; + a[1].value = &length; + + int32 mask = KMIP_CRYPTOMASK_ENCRYPT | KMIP_CRYPTOMASK_DECRYPT; + a[2].type = KMIP_ATTR_CRYPTOGRAPHIC_USAGE_MASK; + a[2].value = &mask; + + struct text_string value = {0}; + value.value = "Key1"; + value.size = 4; + + struct name name = {0}; + name.value = &value; + name.type = KMIP_NAME_UNINTERPRETED_TEXT_STRING; + a[3].type = KMIP_ATTR_NAME; + a[3].value = &name; + + struct template_attribute ta = {0}; + ta.names = &n; + ta.name_count = 1; + ta.attributes = a; + ta.attribute_count = ARRAY_LENGTH(a); + + int result = kmip_encode_template_attribute(&ctx, &ta); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_decode_template_attribute(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[288] = { + 0x42, 0x00, 0x91, 0x01, 0x00, 0x00, 0x01, 0x18, + 0x42, 0x00, 0x53, 0x01, 0x00, 0x00, 0x00, 0x28, + 0x42, 0x00, 0x55, 0x07, 0x00, 0x00, 0x00, 0x09, + 0x54, 0x65, 0x6D, 0x70, 0x6C, 0x61, 0x74, 0x65, + 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x54, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30, + 0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x17, + 0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, + 0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x41, 0x6C, + 0x67, 0x6F, 0x72, 0x69, 0x74, 0x68, 0x6D, 0x00, + 0x42, 0x00, 0x0B, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30, + 0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x14, + 0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, + 0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x4C, 0x65, + 0x6E, 0x67, 0x74, 0x68, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x0B, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30, + 0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x18, + 0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, + 0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x55, 0x73, + 0x61, 0x67, 0x65, 0x20, 0x4D, 0x61, 0x73, 0x6B, + 0x42, 0x00, 0x0B, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x38, + 0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x04, + 0x4E, 0x61, 0x6D, 0x65, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x0B, 0x01, 0x00, 0x00, 0x00, 0x20, + 0x42, 0x00, 0x55, 0x07, 0x00, 0x00, 0x00, 0x04, + 0x4B, 0x65, 0x79, 0x31, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x54, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00 + }; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0); + + struct text_string v = {0}; + v.value = "Template1"; + v.size = 9; + + struct name n = {0}; + n.value = &v; + n.type = KMIP_NAME_UNINTERPRETED_TEXT_STRING; + + struct attribute a[4] = {0}; + for(int i = 0; i < 4; i++) + { + kmip_init_attribute(&a[i]); + } + + enum cryptographic_algorithm algorithm = KMIP_CRYPTOALG_AES; + a[0].type = KMIP_ATTR_CRYPTOGRAPHIC_ALGORITHM; + a[0].value = &algorithm; + + int32 length = 128; + a[1].type = KMIP_ATTR_CRYPTOGRAPHIC_LENGTH; + a[1].value = &length; + + int32 mask = KMIP_CRYPTOMASK_ENCRYPT | KMIP_CRYPTOMASK_DECRYPT; + a[2].type = KMIP_ATTR_CRYPTOGRAPHIC_USAGE_MASK; + a[2].value = &mask; + + struct text_string value = {0}; + value.value = "Key1"; + value.size = 4; + + struct name name = {0}; + name.value = &value; + name.type = KMIP_NAME_UNINTERPRETED_TEXT_STRING; + a[3].type = KMIP_ATTR_NAME; + a[3].value = &name; + + struct template_attribute expected = {0}; + expected.names = &n; + expected.name_count = 1; + expected.attributes = a; + expected.attribute_count = ARRAY_LENGTH(a); + struct template_attribute observed = {0}; + + int result = kmip_decode_template_attribute(&ctx, &observed); + result = report_decoding_test_result( + tracker, + &ctx, + kmip_compare_template_attribute(&expected, &observed), + result, + __func__); + kmip_free_template_attribute(&ctx, &observed); + kmip_destroy(&ctx); + return(result); +} + +/* +The following tests cover features added in KMIP 1.1. +*/ + +int +test_encode_device_credential(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 expected[144] = { + 0x42, 0x00, 0x25, 0x01, 0x00, 0x00, 0x00, 0x88, + 0x42, 0x00, 0xB0, 0x07, 0x00, 0x00, 0x00, 0x0C, + 0x73, 0x65, 0x72, 0x4E, 0x75, 0x6D, 0x31, 0x32, + 0x33, 0x34, 0x35, 0x36, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xA1, 0x07, 0x00, 0x00, 0x00, 0x06, + 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x00, 0x00, + 0x42, 0x00, 0xA2, 0x07, 0x00, 0x00, 0x00, 0x09, + 0x64, 0x65, 0x76, 0x49, 0x44, 0x32, 0x32, 0x33, + 0x33, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xAB, 0x07, 0x00, 0x00, 0x00, 0x09, + 0x6E, 0x65, 0x74, 0x49, 0x44, 0x39, 0x30, 0x30, + 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xA9, 0x07, 0x00, 0x00, 0x00, 0x0A, + 0x6D, 0x61, 0x63, 0x68, 0x69, 0x6E, 0x65, 0x49, + 0x44, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xAA, 0x07, 0x00, 0x00, 0x00, 0x0A, + 0x6D, 0x65, 0x64, 0x69, 0x61, 0x49, 0x44, 0x33, + 0x31, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[144] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_1); + + struct text_string dsn = {0}; + dsn.value = "serNum123456"; + dsn.size = 12; + + struct text_string p = {0}; + p.value = "secret"; + p.size = 6; + + struct text_string di = {0}; + di.value = "devID2233"; + di.size = 9; + + struct text_string ni = {0}; + ni.value = "netID9000"; + ni.size = 9; + + struct text_string mac = {0}; + mac.value = "machineID1"; + mac.size = 10; + + struct text_string med = {0}; + med.value = "mediaID313"; + med.size = 10; + + struct device_credential dc = {0}; + dc.device_serial_number = &dsn; + dc.password = &p; + dc.device_identifier = &di; + dc.network_identifier = ∋ + dc.machine_identifier = &mac; + dc.media_identifier = &med; + + int result = kmip_encode_device_credential(&ctx, &dc); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_decode_device_credential(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[144] = { + 0x42, 0x00, 0x25, 0x01, 0x00, 0x00, 0x00, 0x88, + 0x42, 0x00, 0xB0, 0x07, 0x00, 0x00, 0x00, 0x0C, + 0x73, 0x65, 0x72, 0x4E, 0x75, 0x6D, 0x31, 0x32, + 0x33, 0x34, 0x35, 0x36, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xA1, 0x07, 0x00, 0x00, 0x00, 0x06, + 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x00, 0x00, + 0x42, 0x00, 0xA2, 0x07, 0x00, 0x00, 0x00, 0x09, + 0x64, 0x65, 0x76, 0x49, 0x44, 0x32, 0x32, 0x33, + 0x33, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xAB, 0x07, 0x00, 0x00, 0x00, 0x09, + 0x6E, 0x65, 0x74, 0x49, 0x44, 0x39, 0x30, 0x30, + 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xA9, 0x07, 0x00, 0x00, 0x00, 0x0A, + 0x6D, 0x61, 0x63, 0x68, 0x69, 0x6E, 0x65, 0x49, + 0x44, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xAA, 0x07, 0x00, 0x00, 0x00, 0x0A, + 0x6D, 0x65, 0x64, 0x69, 0x61, 0x49, 0x44, 0x33, + 0x31, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 + }; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_1); + + struct text_string dsn = {0}; + dsn.value = "serNum123456"; + dsn.size = 12; + + struct text_string p = {0}; + p.value = "secret"; + p.size = 6; + + struct text_string di = {0}; + di.value = "devID2233"; + di.size = 9; + + struct text_string ni = {0}; + ni.value = "netID9000"; + ni.size = 9; + + struct text_string mac = {0}; + mac.value = "machineID1"; + mac.size = 10; + + struct text_string med = {0}; + med.value = "mediaID313"; + med.size = 10; + + struct device_credential expected = {0}; + expected.device_serial_number = &dsn; + expected.password = &p; + expected.device_identifier = &di; + expected.network_identifier = ∋ + expected.machine_identifier = &mac; + expected.media_identifier = &med; + + struct device_credential observed = {0}; + + int result = kmip_decode_device_credential(&ctx, &observed); + result = report_decoding_test_result( + tracker, + &ctx, + kmip_compare_device_credential(&expected, &observed), + result, + __func__); + kmip_free_device_credential(&ctx, &observed); + kmip_destroy(&ctx); + return(result); +} + +int +test_encode_key_wrapping_data_with_encoding_option(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 expected[120] = { + 0x42, 0x00, 0x46, 0x01, 0x00, 0x00, 0x00, 0x70, + 0x42, 0x00, 0x9E, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x36, 0x01, 0x00, 0x00, 0x00, 0x48, + 0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, + 0x31, 0x30, 0x30, 0x31, 0x38, 0x32, 0x64, 0x35, + 0x2D, 0x37, 0x32, 0x62, 0x38, 0x2D, 0x34, 0x37, + 0x61, 0x61, 0x2D, 0x38, 0x33, 0x38, 0x33, 0x2D, + 0x34, 0x64, 0x39, 0x37, 0x64, 0x35, 0x31, 0x32, + 0x65, 0x39, 0x38, 0x61, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x2B, 0x01, 0x00, 0x00, 0x00, 0x10, + 0x42, 0x00, 0x11, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xA3, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[120] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_1); + + struct text_string uuid = {0}; + uuid.value = "100182d5-72b8-47aa-8383-4d97d512e98a"; + uuid.size = 36; + + struct cryptographic_parameters cp = {0}; + cp.block_cipher_mode = KMIP_BLOCK_NIST_KEY_WRAP; + + struct encryption_key_information eki = {0}; + eki.unique_identifier = &uuid; + eki.cryptographic_parameters = &cp; + + struct key_wrapping_data kwd = {0}; + kwd.wrapping_method = KMIP_WRAP_ENCRYPT; + kwd.encryption_key_info = &eki; + kwd.encoding_option = KMIP_ENCODE_NO_ENCODING; + + int result = kmip_encode_key_wrapping_data(&ctx, &kwd); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_decode_key_wrapping_data_with_encoding_option(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[120] = { + 0x42, 0x00, 0x46, 0x01, 0x00, 0x00, 0x00, 0x70, + 0x42, 0x00, 0x9E, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x36, 0x01, 0x00, 0x00, 0x00, 0x48, + 0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, + 0x31, 0x30, 0x30, 0x31, 0x38, 0x32, 0x64, 0x35, + 0x2D, 0x37, 0x32, 0x62, 0x38, 0x2D, 0x34, 0x37, + 0x61, 0x61, 0x2D, 0x38, 0x33, 0x38, 0x33, 0x2D, + 0x34, 0x64, 0x39, 0x37, 0x64, 0x35, 0x31, 0x32, + 0x65, 0x39, 0x38, 0x61, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x2B, 0x01, 0x00, 0x00, 0x00, 0x10, + 0x42, 0x00, 0x11, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xA3, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00 + }; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_1); + + struct text_string uuid = {0}; + uuid.value = "100182d5-72b8-47aa-8383-4d97d512e98a"; + uuid.size = 36; + + struct cryptographic_parameters cp = {0}; + kmip_init_cryptographic_parameters(&cp); + cp.block_cipher_mode = KMIP_BLOCK_NIST_KEY_WRAP; + + struct encryption_key_information eki = {0}; + eki.unique_identifier = &uuid; + eki.cryptographic_parameters = &cp; + + struct key_wrapping_data expected = {0}; + expected.wrapping_method = KMIP_WRAP_ENCRYPT; + expected.encryption_key_info = &eki; + expected.encoding_option = KMIP_ENCODE_NO_ENCODING; + + struct key_wrapping_data observed = {0}; + + int result = kmip_decode_key_wrapping_data(&ctx, &observed); + result = report_decoding_test_result( + tracker, + &ctx, + kmip_compare_key_wrapping_data(&expected, &observed), + result, + __func__); + kmip_free_key_wrapping_data(&ctx, &observed); + kmip_destroy(&ctx); + return(result); +} + +int +test_encode_key_wrapping_specification_with_encoding_option(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 expected[120] = { + 0x42, 0x00, 0x47, 0x01, 0x00, 0x00, 0x00, 0x70, + 0x42, 0x00, 0x9E, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x36, 0x01, 0x00, 0x00, 0x00, 0x48, + 0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, + 0x31, 0x30, 0x30, 0x31, 0x38, 0x32, 0x64, 0x35, + 0x2D, 0x37, 0x32, 0x62, 0x38, 0x2D, 0x34, 0x37, + 0x61, 0x61, 0x2D, 0x38, 0x33, 0x38, 0x33, 0x2D, + 0x34, 0x64, 0x39, 0x37, 0x64, 0x35, 0x31, 0x32, + 0x65, 0x39, 0x38, 0x61, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x2B, 0x01, 0x00, 0x00, 0x00, 0x10, + 0x42, 0x00, 0x11, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xA3, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[120] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_1); + + struct text_string uuid = {0}; + uuid.value = "100182d5-72b8-47aa-8383-4d97d512e98a"; + uuid.size = 36; + + struct cryptographic_parameters cp = {0}; + cp.block_cipher_mode = KMIP_BLOCK_NIST_KEY_WRAP; + + struct encryption_key_information eki = {0}; + eki.unique_identifier = &uuid; + eki.cryptographic_parameters = &cp; + + struct key_wrapping_specification kws = {0}; + kws.wrapping_method = KMIP_WRAP_ENCRYPT; + kws.encryption_key_info = &eki; + kws.encoding_option = KMIP_ENCODE_NO_ENCODING; + + int result = kmip_encode_key_wrapping_specification(&ctx, &kws); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +/* +The following tests cover features added in KMIP 1.2. +*/ + +int +test_encode_nonce(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 expected[40] = { + 0x42, 0x00, 0xC8, 0x01, 0x00, 0x00, 0x00, 0x20, + 0x42, 0x00, 0xC9, 0x08, 0x00, 0x00, 0x00, 0x04, + 0x01, 0x02, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xCA, 0x08, 0x00, 0x00, 0x00, 0x06, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00 + }; + + uint8 observed[40] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_2); + + uint8 id[4] = {0x01, 0x02, 0x03, 0x04}; + struct byte_string ni = {0}; + ni.value = id; + ni.size = ARRAY_LENGTH(id); + + uint8 value[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}; + struct byte_string nv = {0}; + nv.value = value; + nv.size = ARRAY_LENGTH(value); + + struct nonce n = {0}; + n.nonce_id = ∋ + n.nonce_value = &nv; + + int result = kmip_encode_nonce(&ctx, &n); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_decode_nonce(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[40] = { + 0x42, 0x00, 0xC8, 0x01, 0x00, 0x00, 0x00, 0x20, + 0x42, 0x00, 0xC9, 0x08, 0x00, 0x00, 0x00, 0x04, + 0x01, 0x02, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xCA, 0x08, 0x00, 0x00, 0x00, 0x06, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00 + }; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_2); + + uint8 id[4] = {0x01, 0x02, 0x03, 0x04}; + struct byte_string ni = {0}; + ni.value = id; + ni.size = ARRAY_LENGTH(id); + + uint8 value[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}; + struct byte_string nv = {0}; + nv.value = value; + nv.size = ARRAY_LENGTH(value); + + struct nonce expected = {0}; + expected.nonce_id = ∋ + expected.nonce_value = &nv; + + struct nonce observed = {0}; + + int result = kmip_decode_nonce(&ctx, &observed); + result = report_decoding_test_result( + tracker, + &ctx, + kmip_compare_nonce(&expected, &observed), + result, + __func__); + kmip_free_nonce(&ctx, &observed); + kmip_destroy(&ctx); + return(result); +} + +int +test_encode_attestation_credential(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 expected[128] = { + 0x42, 0x00, 0x25, 0x01, 0x00, 0x00, 0x00, 0x70, + 0x42, 0x00, 0xC8, 0x01, 0x00, 0x00, 0x00, 0x20, + 0x42, 0x00, 0xC9, 0x08, 0x00, 0x00, 0x00, 0x04, + 0x01, 0x02, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xCA, 0x08, 0x00, 0x00, 0x00, 0x06, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, + 0x42, 0x00, 0xC7, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xCB, 0x08, 0x00, 0x00, 0x00, 0x10, + 0x22, 0x22, 0x22, 0x22, 0x44, 0x44, 0x44, 0x44, + 0x66, 0x66, 0x66, 0x66, 0x88, 0x88, 0x88, 0x88, + 0x42, 0x00, 0xCC, 0x08, 0x00, 0x00, 0x00, 0x14, + 0x11, 0x11, 0x11, 0x11, 0x33, 0x33, 0x33, 0x33, + 0x55, 0x55, 0x55, 0x55, 0x77, 0x77, 0x77, 0x77, + 0x99, 0x99, 0x99, 0x99, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[128] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_2); + + uint8 nonce_id[4] = {0x01, 0x02, 0x03, 0x04}; + struct byte_string ni = {0}; + ni.value = nonce_id; + ni.size = ARRAY_LENGTH(nonce_id); + + uint8 nonce_value[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}; + struct byte_string nv = {0}; + nv.value = nonce_value; + nv.size = ARRAY_LENGTH(nonce_value); + + struct nonce n = {0}; + n.nonce_id = ∋ + n.nonce_value = &nv; + + uint8 measurement[16] = { + 0x22, 0x22, 0x22, 0x22, 0x44, 0x44, 0x44, 0x44, + 0x66, 0x66, 0x66, 0x66, 0x88, 0x88, 0x88, 0x88 + }; + struct byte_string am = {0}; + am.value = measurement; + am.size = ARRAY_LENGTH(measurement); + + uint8 assertion[20] = { + 0x11, 0x11, 0x11, 0x11, 0x33, 0x33, 0x33, 0x33, + 0x55, 0x55, 0x55, 0x55, 0x77, 0x77, 0x77, 0x77, + 0x99, 0x99, 0x99, 0x99 + }; + struct byte_string aa = {0}; + aa.value = assertion; + aa.size = ARRAY_LENGTH(assertion); + + struct attestation_credential ac = {0}; + ac.nonce = &n; + ac.attestation_type = KMIP_ATTEST_TPM_QUOTE; + ac.attestation_measurement = &am; + ac.attestation_assertion = &aa; + + int result = kmip_encode_attestation_credential(&ctx, &ac); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_decode_attestation_credential(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[128] = { + 0x42, 0x00, 0x25, 0x01, 0x00, 0x00, 0x00, 0x70, + 0x42, 0x00, 0xC8, 0x01, 0x00, 0x00, 0x00, 0x20, + 0x42, 0x00, 0xC9, 0x08, 0x00, 0x00, 0x00, 0x04, + 0x01, 0x02, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xCA, 0x08, 0x00, 0x00, 0x00, 0x06, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, + 0x42, 0x00, 0xC7, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xCB, 0x08, 0x00, 0x00, 0x00, 0x10, + 0x22, 0x22, 0x22, 0x22, 0x44, 0x44, 0x44, 0x44, + 0x66, 0x66, 0x66, 0x66, 0x88, 0x88, 0x88, 0x88, + 0x42, 0x00, 0xCC, 0x08, 0x00, 0x00, 0x00, 0x14, + 0x11, 0x11, 0x11, 0x11, 0x33, 0x33, 0x33, 0x33, + 0x55, 0x55, 0x55, 0x55, 0x77, 0x77, 0x77, 0x77, + 0x99, 0x99, 0x99, 0x99, 0x00, 0x00, 0x00, 0x00 + }; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_2); + + uint8 nonce_id[4] = {0x01, 0x02, 0x03, 0x04}; + struct byte_string ni = {0}; + ni.value = nonce_id; + ni.size = ARRAY_LENGTH(nonce_id); + + uint8 nonce_value[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}; + struct byte_string nv = {0}; + nv.value = nonce_value; + nv.size = ARRAY_LENGTH(nonce_value); + + struct nonce n = {0}; + n.nonce_id = ∋ + n.nonce_value = &nv; + + uint8 measurement[16] = { + 0x22, 0x22, 0x22, 0x22, 0x44, 0x44, 0x44, 0x44, + 0x66, 0x66, 0x66, 0x66, 0x88, 0x88, 0x88, 0x88 + }; + struct byte_string am = {0}; + am.value = measurement; + am.size = ARRAY_LENGTH(measurement); + + uint8 assertion[20] = { + 0x11, 0x11, 0x11, 0x11, 0x33, 0x33, 0x33, 0x33, + 0x55, 0x55, 0x55, 0x55, 0x77, 0x77, 0x77, 0x77, + 0x99, 0x99, 0x99, 0x99 + }; + struct byte_string aa = {0}; + aa.value = assertion; + aa.size = ARRAY_LENGTH(assertion); + + struct attestation_credential expected = {0}; + expected.nonce = &n; + expected.attestation_type = KMIP_ATTEST_TPM_QUOTE; + expected.attestation_measurement = &am; + expected.attestation_assertion = &aa; + + struct attestation_credential observed = {0}; + + int result = kmip_decode_attestation_credential(&ctx, &observed); + result = report_decoding_test_result( + tracker, + &ctx, + kmip_compare_attestation_credential(&expected, &observed), + result, + __func__); + kmip_free_attestation_credential(&ctx, &observed); + kmip_destroy(&ctx); + return(result); +} + +int +test_encode_request_header_with_attestation_details(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 expected[216] = { + 0x42, 0x00, 0x77, 0x01, 0x00, 0x00, 0x00, 0xD0, + 0x42, 0x00, 0x69, 0x01, 0x00, 0x00, 0x00, 0x20, + 0x42, 0x00, 0x6A, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x6B, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xD3, 0x06, 0x00, 0x00, 0x00, 0x08, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, + 0x42, 0x00, 0xC7, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xC7, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x0C, 0x01, 0x00, 0x00, 0x00, 0x40, + 0x42, 0x00, 0x23, 0x01, 0x00, 0x00, 0x00, 0x38, + 0x42, 0x00, 0x24, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x25, 0x01, 0x00, 0x00, 0x00, 0x20, + 0x42, 0x00, 0x99, 0x07, 0x00, 0x00, 0x00, 0x06, + 0x42, 0x61, 0x72, 0x6E, 0x65, 0x79, 0x00, 0x00, + 0x42, 0x00, 0xA1, 0x07, 0x00, 0x00, 0x00, 0x07, + 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x32, 0x00, + 0x42, 0x00, 0x0E, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x10, 0x06, 0x00, 0x00, 0x00, 0x08, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, + 0x42, 0x00, 0x0D, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[216] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_2); + + struct protocol_version pv = {0}; + pv.major = 1; + pv.minor = 0; + + struct text_string username = {0}; + username.value = "Barney"; + username.size = 6; + struct text_string password = {0}; + password.value = "secret2"; + password.size = 7; + + struct username_password_credential upc = {0}; + upc.username = &username; + upc.password = &password; + + struct credential c = {0}; + c.credential_type = KMIP_CRED_USERNAME_AND_PASSWORD; + c.credential_value = &upc; + + struct authentication a = {0}; + a.credential = &c; + + enum attestation_type types[2] = { + KMIP_ATTEST_TPM_QUOTE, + KMIP_ATTEST_SAML_ASSERTION + }; + + struct request_header rh = {0}; + kmip_init_request_header(&rh); + + rh.protocol_version = &pv; + rh.attestation_capable_indicator = KMIP_TRUE; + rh.attestation_types = types; + rh.attestation_type_count = ARRAY_LENGTH(types); + rh.authentication = &a; + rh.batch_error_continuation_option = KMIP_BATCH_CONTINUE; + rh.batch_order_option = KMIP_TRUE; + rh.batch_count = 2; + + int result = kmip_encode_request_header(&ctx, &rh); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_encode_response_header_with_attestation_details(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 expected[152] = { + 0x42, 0x00, 0x7A, 0x01, 0x00, 0x00, 0x00, 0x90, + 0x42, 0x00, 0x69, 0x01, 0x00, 0x00, 0x00, 0x20, + 0x42, 0x00, 0x6A, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x6B, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x92, 0x09, 0x00, 0x00, 0x00, 0x08, + 0x00, 0x00, 0x00, 0x00, 0x4F, 0x9A, 0x54, 0xE5, + 0x42, 0x00, 0xC8, 0x01, 0x00, 0x00, 0x00, 0x20, + 0x42, 0x00, 0xC9, 0x08, 0x00, 0x00, 0x00, 0x04, + 0x01, 0x02, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xCA, 0x08, 0x00, 0x00, 0x00, 0x06, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, + 0x42, 0x00, 0xC7, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xC7, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x0D, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[152] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_2); + + struct protocol_version pv = {0}; + pv.major = 1; + pv.minor = 0; + + uint8 id[4] = {0x01, 0x02, 0x03, 0x04}; + struct byte_string ni = {0}; + ni.value = id; + ni.size = ARRAY_LENGTH(id); + + uint8 value[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}; + struct byte_string nv = {0}; + nv.value = value; + nv.size = ARRAY_LENGTH(value); + + struct nonce n = {0}; + n.nonce_id = ∋ + n.nonce_value = &nv; + + enum attestation_type types[2] = { + KMIP_ATTEST_TPM_QUOTE, + KMIP_ATTEST_SAML_ASSERTION + }; + + struct response_header rh = {0}; + kmip_init_response_header(&rh); + + rh.protocol_version = &pv; + rh.time_stamp = 1335514341; + rh.nonce = &n; + rh.attestation_types = types; + rh.attestation_type_count = ARRAY_LENGTH(types); + rh.batch_count = 1; + + int result = kmip_encode_response_header(&ctx, &rh); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_decode_response_header_with_attestation_details(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[152] = { + 0x42, 0x00, 0x7A, 0x01, 0x00, 0x00, 0x00, 0x90, + 0x42, 0x00, 0x69, 0x01, 0x00, 0x00, 0x00, 0x20, + 0x42, 0x00, 0x6A, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x6B, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x92, 0x09, 0x00, 0x00, 0x00, 0x08, + 0x00, 0x00, 0x00, 0x00, 0x4F, 0x9A, 0x54, 0xE5, + 0x42, 0x00, 0xC8, 0x01, 0x00, 0x00, 0x00, 0x20, + 0x42, 0x00, 0xC9, 0x08, 0x00, 0x00, 0x00, 0x04, + 0x01, 0x02, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xCA, 0x08, 0x00, 0x00, 0x00, 0x06, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, + 0x42, 0x00, 0xC7, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xC7, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x0D, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00 + }; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_2); + + struct protocol_version pv = {0}; + pv.major = 1; + pv.minor = 0; + + uint8 id[4] = {0x01, 0x02, 0x03, 0x04}; + struct byte_string ni = {0}; + ni.value = id; + ni.size = ARRAY_LENGTH(id); + + uint8 value[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}; + struct byte_string nv = {0}; + nv.value = value; + nv.size = ARRAY_LENGTH(value); + + struct nonce n = {0}; + n.nonce_id = ∋ + n.nonce_value = &nv; + + enum attestation_type types[2] = { + KMIP_ATTEST_TPM_QUOTE, + KMIP_ATTEST_SAML_ASSERTION + }; + + struct response_header expected = {0}; + kmip_init_response_header(&expected); + + expected.protocol_version = &pv; + expected.time_stamp = 1335514341; + expected.nonce = &n; + expected.attestation_types = types; + expected.attestation_type_count = ARRAY_LENGTH(types); + expected.batch_count = 1; + + struct response_header observed = {0}; + kmip_init_response_header(&observed); + + int result = kmip_decode_response_header(&ctx, &observed); + result = report_decoding_test_result( + tracker, + &ctx, + kmip_compare_response_header(&expected, &observed), + result, + __func__); + kmip_free_response_header(&ctx, &observed); + kmip_destroy(&ctx); + return(result); +} + +int +test_encode_cryptographic_parameters_with_digital_signature_fields(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 expected[216] = { + 0x42, 0x00, 0x2B, 0x01, 0x00, 0x00, 0x00, 0xD0, + 0x42, 0x00, 0x11, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x5F, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x38, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x83, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xAE, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x28, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xC5, 0x06, 0x00, 0x00, 0x00, 0x08, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, + 0x42, 0x00, 0xCD, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xCE, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xCF, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xD2, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xD0, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xD1, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[216] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_2); + + struct cryptographic_parameters cp = {0}; + cp.block_cipher_mode = KMIP_BLOCK_CBC; + cp.padding_method = KMIP_PAD_PKCS5; + cp.hashing_algorithm = KMIP_HASH_SHA1; + cp.key_role_type = KMIP_ROLE_KEK; + + cp.digital_signature_algorithm = KMIP_DIGITAL_SHA256_WITH_RSA; + cp.cryptographic_algorithm = KMIP_CRYPTOALG_RSA; + cp.random_iv = KMIP_TRUE; + cp.iv_length = 128; + cp.tag_length = 64; + cp.fixed_field_length = 64; + cp.invocation_field_length = 64; + cp.counter_length = 256; + cp.initial_counter_value = 0; + + int result = kmip_encode_cryptographic_parameters(&ctx, &cp); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_decode_cryptographic_parameters_with_digital_signature_fields(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[216] = { + 0x42, 0x00, 0x2B, 0x01, 0x00, 0x00, 0x00, 0xD0, + 0x42, 0x00, 0x11, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x5F, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x38, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x83, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xAE, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00 ,0x00, 0x05, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x28, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xC5, 0x06, 0x00, 0x00, 0x00, 0x08, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, + 0x42, 0x00, 0xCD, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xCE, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xCF, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xD2, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xD0, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xD1, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 + }; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_2); + + struct cryptographic_parameters expected = {0}; + kmip_init_cryptographic_parameters(&expected); + expected.block_cipher_mode = KMIP_BLOCK_CBC; + expected.padding_method = KMIP_PAD_PKCS5; + expected.hashing_algorithm = KMIP_HASH_SHA1; + expected.key_role_type = KMIP_ROLE_KEK; + + expected.digital_signature_algorithm = KMIP_DIGITAL_SHA256_WITH_RSA; + expected.cryptographic_algorithm = KMIP_CRYPTOALG_RSA; + expected.random_iv = KMIP_TRUE; + expected.iv_length = 128; + expected.tag_length = 64; + expected.fixed_field_length = 64; + expected.invocation_field_length = 64; + expected.counter_length = 256; + expected.initial_counter_value = 0; + + struct cryptographic_parameters observed = {0}; + kmip_init_cryptographic_parameters(&observed); + + int result = kmip_decode_cryptographic_parameters(&ctx, &observed); + result = report_decoding_test_result( + tracker, + &ctx, + kmip_compare_cryptographic_parameters(&expected, &observed), + result, + __func__); + kmip_free_cryptographic_parameters(&ctx, &observed); + kmip_destroy(&ctx); + return(result); +} + +/* +The following tests cover features added in KMIP 1.4. +*/ + +int +test_encode_cryptographic_parameters_with_mask_fields(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 expected[312] = { + 0x42, 0x00, 0x2B, 0x01, 0x00, 0x00, 0x01, 0x30, + 0x42, 0x00, 0x11, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x5F, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x38, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x83, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xAE, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x28, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xC5, 0x06, 0x00, 0x00, 0x00, 0x08, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, + 0x42, 0x00, 0xCD, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xCE, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xCF, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xD2, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xD0, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xD1, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x01, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x01, 0x01, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x01, 0x02, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x01, 0x03, 0x08, 0x00, 0x00, 0x00, 0x18, + 0x73, 0x67, 0x57, 0x80, 0x51, 0x01, 0x2A, 0x6D, + 0x13, 0x4A, 0x85, 0x5E, 0x25, 0xC8, 0xCD, 0x5E, + 0x4C, 0xA1, 0x31, 0x45, 0x57, 0x29, 0xD3, 0xC8, + 0x42, 0x01, 0x04, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[312] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_4); + + uint8 value[24] = { + 0x73, 0x67, 0x57, 0x80, 0x51, 0x01, 0x2A, 0x6D, + 0x13, 0x4A, 0x85, 0x5E, 0x25, 0xC8, 0xCD, 0x5E, + 0x4C, 0xA1, 0x31, 0x45, 0x57, 0x29, 0xD3, 0xC8 + }; + struct byte_string ps = {0}; + ps.value = value; + ps.size = ARRAY_LENGTH(value); + + struct cryptographic_parameters cp = {0}; + cp.block_cipher_mode = KMIP_BLOCK_CBC; + cp.padding_method = KMIP_PAD_PKCS5; + cp.hashing_algorithm = KMIP_HASH_SHA1; + cp.key_role_type = KMIP_ROLE_KEK; + + cp.digital_signature_algorithm = KMIP_DIGITAL_SHA256_WITH_RSA; + cp.cryptographic_algorithm = KMIP_CRYPTOALG_RSA; + cp.random_iv = KMIP_TRUE; + cp.iv_length = 128; + cp.tag_length = 64; + cp.fixed_field_length = 64; + cp.invocation_field_length = 64; + cp.counter_length = 256; + cp.initial_counter_value = 0; + + cp.salt_length = 32; + cp.mask_generator = KMIP_MASKGEN_MGF1; + cp.mask_generator_hashing_algorithm = KMIP_HASH_SHA256; + cp.p_source = &ps; + cp.trailer_field = 1; + + int result = kmip_encode_cryptographic_parameters(&ctx, &cp); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_decode_cryptographic_parameters_with_mask_fields(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[312] = { + 0x42, 0x00, 0x2B, 0x01, 0x00, 0x00, 0x01, 0x30, + 0x42, 0x00, 0x11, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x5F, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x38, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x83, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xAE, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x28, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xC5, 0x06, 0x00, 0x00, 0x00, 0x08, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, + 0x42, 0x00, 0xCD, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xCE, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xCF, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xD2, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xD0, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xD1, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x01, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x01, 0x01, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x01, 0x02, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x01, 0x03, 0x08, 0x00, 0x00, 0x00, 0x18, + 0x73, 0x67, 0x57, 0x80, 0x51, 0x01, 0x2A, 0x6D, + 0x13, 0x4A, 0x85, 0x5E, 0x25, 0xC8, 0xCD, 0x5E, + 0x4C, 0xA1, 0x31, 0x45, 0x57, 0x29, 0xD3, 0xC8, + 0x42, 0x01, 0x04, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00 + }; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_4); + + uint8 value[24] = { + 0x73, 0x67, 0x57, 0x80, 0x51, 0x01, 0x2A, 0x6D, + 0x13, 0x4A, 0x85, 0x5E, 0x25, 0xC8, 0xCD, 0x5E, + 0x4C, 0xA1, 0x31, 0x45, 0x57, 0x29, 0xD3, 0xC8 + }; + struct byte_string ps = {0}; + ps.value = value; + ps.size = ARRAY_LENGTH(value); + + struct cryptographic_parameters expected = {0}; + kmip_init_cryptographic_parameters(&expected); + + expected.block_cipher_mode = KMIP_BLOCK_CBC; + expected.padding_method = KMIP_PAD_PKCS5; + expected.hashing_algorithm = KMIP_HASH_SHA1; + expected.key_role_type = KMIP_ROLE_KEK; + + expected.digital_signature_algorithm = KMIP_DIGITAL_SHA256_WITH_RSA; + expected.cryptographic_algorithm = KMIP_CRYPTOALG_RSA; + expected.random_iv = KMIP_TRUE; + expected.iv_length = 128; + expected.tag_length = 64; + expected.fixed_field_length = 64; + expected.invocation_field_length = 64; + expected.counter_length = 256; + expected.initial_counter_value = 0; + + expected.salt_length = 32; + expected.mask_generator = KMIP_MASKGEN_MGF1; + expected.mask_generator_hashing_algorithm = KMIP_HASH_SHA256; + expected.p_source = &ps; + expected.trailer_field = 1; + + struct cryptographic_parameters observed = {0}; + kmip_init_cryptographic_parameters(&observed); + + int result = kmip_decode_cryptographic_parameters(&ctx, &observed); + result = report_decoding_test_result( + tracker, + &ctx, + kmip_compare_cryptographic_parameters(&expected, &observed), + result, + __func__); + kmip_free_cryptographic_parameters(&ctx, &observed); + kmip_destroy(&ctx); + return(result); +} + +int +test_encode_get_request_payload_with_wrap_type(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 expected[104] = { + 0x42, 0x00, 0x79, 0x01, 0x00, 0x00, 0x00, 0x60, + 0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, + 0x37, 0x63, 0x66, 0x35, 0x32, 0x30, 0x39, 0x62, + 0x2D, 0x36, 0x66, 0x66, 0x36, 0x2D, 0x34, 0x34, + 0x32, 0x36, 0x2D, 0x38, 0x39, 0x39, 0x65, 0x2D, + 0x32, 0x32, 0x62, 0x30, 0x36, 0x37, 0x38, 0x35, + 0x39, 0x33, 0x37, 0x32, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x42, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xF8, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x41, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[104] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_4); + + struct text_string uuid = {0}; + uuid.value = "7cf5209b-6ff6-4426-899e-22b067859372"; + uuid.size = 36; + + struct get_request_payload grp = {0}; + grp.unique_identifier = &uuid; + grp.key_format_type = KMIP_KEYFORMAT_PKCS1; + grp.key_compression_type = KMIP_KEYCOMP_EC_PUB_UNCOMPRESSED; + + grp.key_wrap_type = KMIP_WRAPTYPE_NOT_WRAPPED; + + int result = kmip_encode_get_request_payload(&ctx, &grp); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_encode_request_header_with_correlation_values(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 expected[280] = { + 0x42, 0x00, 0x77, 0x01, 0x00, 0x00, 0x01, 0x10, + 0x42, 0x00, 0x69, 0x01, 0x00, 0x00, 0x00, 0x20, + 0x42, 0x00, 0x6A, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x6B, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x50, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x01, 0x05, 0x07, 0x00, 0x00, 0x00, 0x08, + 0x63, 0x6C, 0x69, 0x65, 0x6E, 0x74, 0x20, 0x31, + 0x42, 0x01, 0x06, 0x07, 0x00, 0x00, 0x00, 0x08, + 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x20, 0x31, + 0x42, 0x00, 0x07, 0x06, 0x00, 0x00, 0x00, 0x08, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, + 0x42, 0x00, 0xD3, 0x06, 0x00, 0x00, 0x00, 0x08, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, + 0x42, 0x00, 0xC7, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xC7, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x0C, 0x01, 0x00, 0x00, 0x00, 0x40, + 0x42, 0x00, 0x23, 0x01, 0x00, 0x00, 0x00, 0x38, + 0x42, 0x00, 0x24, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x25, 0x01, 0x00, 0x00, 0x00, 0x20, + 0x42, 0x00, 0x99, 0x07, 0x00, 0x00, 0x00, 0x06, + 0x42, 0x61, 0x72, 0x6E, 0x65, 0x79, 0x00, 0x00, + 0x42, 0x00, 0xA1, 0x07, 0x00, 0x00, 0x00, 0x07, + 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x32, 0x00, + 0x42, 0x00, 0x0E, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x10, 0x06, 0x00, 0x00, 0x00, 0x08, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, + 0x42, 0x00, 0x0D, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[280] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_4); + + struct protocol_version pv = {0}; + pv.major = 1; + pv.minor = 0; + + struct text_string username = {0}; + username.value = "Barney"; + username.size = 6; + struct text_string password = {0}; + password.value = "secret2"; + password.size = 7; + + struct username_password_credential upc = {0}; + upc.username = &username; + upc.password = &password; + + struct credential c = {0}; + c.credential_type = KMIP_CRED_USERNAME_AND_PASSWORD; + c.credential_value = &upc; + + struct authentication a = {0}; + a.credential = &c; + + enum attestation_type types[2] = { + KMIP_ATTEST_TPM_QUOTE, + KMIP_ATTEST_SAML_ASSERTION + }; + + struct text_string ccv = {0}; + ccv.value = "client 1"; + ccv.size = 8; + + struct text_string scv = {0}; + scv.value = "server 1"; + scv.size = 8; + + struct request_header rh = {0}; + kmip_init_request_header(&rh); + + rh.protocol_version = &pv; + rh.maximum_response_size = 4096; + rh.asynchronous_indicator = KMIP_TRUE; + rh.attestation_capable_indicator = KMIP_TRUE; + rh.attestation_types = types; + rh.attestation_type_count = ARRAY_LENGTH(types); + rh.authentication = &a; + rh.batch_error_continuation_option = KMIP_BATCH_CONTINUE; + rh.batch_order_option = KMIP_TRUE; + rh.batch_count = 2; + + rh.client_correlation_value = &ccv; + rh.server_correlation_value = &scv; + + int result = kmip_encode_request_header(&ctx, &rh); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_encode_response_header_with_correlation_values(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 expected[184] = { + 0x42, 0x00, 0x7A, 0x01, 0x00, 0x00, 0x00, 0xB0, + 0x42, 0x00, 0x69, 0x01, 0x00, 0x00, 0x00, 0x20, + 0x42, 0x00, 0x6A, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x6B, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x92, 0x09, 0x00, 0x00, 0x00, 0x08, + 0x00, 0x00, 0x00, 0x00, 0x4F, 0x9A, 0x54, 0xE5, + 0x42, 0x00, 0xC8, 0x01, 0x00, 0x00, 0x00, 0x20, + 0x42, 0x00, 0xC9, 0x08, 0x00, 0x00, 0x00, 0x04, + 0x01, 0x02, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xCA, 0x08, 0x00, 0x00, 0x00, 0x06, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, + 0x42, 0x00, 0xC7, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xC7, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x01, 0x05, 0x07, 0x00, 0x00, 0x00, 0x08, + 0x63, 0x6C, 0x69, 0x65, 0x6E, 0x74, 0x20, 0x31, + 0x42, 0x01, 0x06, 0x07, 0x00, 0x00, 0x00, 0x08, + 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x20, 0x31, + 0x42, 0x00, 0x0D, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[184] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_4); + + struct protocol_version pv = {0}; + pv.major = 1; + pv.minor = 0; + + uint8 id[4] = {0x01, 0x02, 0x03, 0x04}; + struct byte_string ni = {0}; + ni.value = id; + ni.size = ARRAY_LENGTH(id); + + uint8 value[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}; + struct byte_string nv = {0}; + nv.value = value; + nv.size = ARRAY_LENGTH(value); + + struct nonce n = {0}; + n.nonce_id = ∋ + n.nonce_value = &nv; + + enum attestation_type types[2] = { + KMIP_ATTEST_TPM_QUOTE, + KMIP_ATTEST_SAML_ASSERTION + }; + + struct text_string ccv = {0}; + ccv.value = "client 1"; + ccv.size = 8; + + struct text_string scv = {0}; + scv.value = "server 1"; + scv.size = 8; + + struct response_header rh = {0}; + kmip_init_response_header(&rh); + + rh.protocol_version = &pv; + rh.time_stamp = 1335514341; + rh.nonce = &n; + rh.attestation_types = types; + rh.attestation_type_count = ARRAY_LENGTH(types); + rh.batch_count = 1; + + rh.client_correlation_value = &ccv; + rh.server_correlation_value = &scv; + + int result = kmip_encode_response_header(&ctx, &rh); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_decode_response_header_with_correlation_values(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 encoding[184] = { + 0x42, 0x00, 0x7A, 0x01, 0x00, 0x00, 0x00, 0xB0, + 0x42, 0x00, 0x69, 0x01, 0x00, 0x00, 0x00, 0x20, + 0x42, 0x00, 0x6A, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x6B, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x92, 0x09, 0x00, 0x00, 0x00, 0x08, + 0x00, 0x00, 0x00, 0x00, 0x4F, 0x9A, 0x54, 0xE5, + 0x42, 0x00, 0xC8, 0x01, 0x00, 0x00, 0x00, 0x20, + 0x42, 0x00, 0xC9, 0x08, 0x00, 0x00, 0x00, 0x04, + 0x01, 0x02, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xCA, 0x08, 0x00, 0x00, 0x00, 0x06, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, + 0x42, 0x00, 0xC7, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xC7, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x01, 0x05, 0x07, 0x00, 0x00, 0x00, 0x08, + 0x63, 0x6C, 0x69, 0x65, 0x6E, 0x74, 0x20, 0x31, + 0x42, 0x01, 0x06, 0x07, 0x00, 0x00, 0x00, 0x08, + 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x20, 0x31, + 0x42, 0x00, 0x0D, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00 + }; + + struct kmip ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_4); + + struct protocol_version pv = {0}; + pv.major = 1; + pv.minor = 0; + + uint8 id[4] = {0x01, 0x02, 0x03, 0x04}; + struct byte_string ni = {0}; + ni.value = id; + ni.size = ARRAY_LENGTH(id); + + uint8 value[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}; + struct byte_string nv = {0}; + nv.value = value; + nv.size = ARRAY_LENGTH(value); + + struct nonce n = {0}; + n.nonce_id = ∋ + n.nonce_value = &nv; + + enum attestation_type types[2] = { + KMIP_ATTEST_TPM_QUOTE, + KMIP_ATTEST_SAML_ASSERTION + }; + + struct text_string ccv = {0}; + ccv.value = "client 1"; + ccv.size = 8; + + struct text_string scv = {0}; + scv.value = "server 1"; + scv.size = 8; + + struct response_header expected = {0}; + kmip_init_response_header(&expected); + + expected.protocol_version = &pv; + expected.time_stamp = 1335514341; + expected.nonce = &n; + expected.attestation_types = types; + expected.attestation_type_count = ARRAY_LENGTH(types); + expected.batch_count = 1; + + expected.client_correlation_value = &ccv; + expected.server_correlation_value = &scv; + + struct response_header observed = {0}; + kmip_init_response_header(&observed); + + int result = kmip_decode_response_header(&ctx, &observed); + result = report_decoding_test_result( + tracker, + &ctx, + kmip_compare_response_header(&expected, &observed), + result, + __func__); + kmip_free_response_header(&ctx, &observed); + kmip_destroy(&ctx); + return(result); +} + +int +test_encode_response_header_kmip_2_0(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + /* This encoding matches the following set of values: + * Response Header + * Protocol Version + * Protocol Version Major - 2 + * Protocol Version Minor - 0 + * Time Stamp - 1335514341 + * Nonce + * Nonce ID - 0x01020304 + * Nonce Value - 0xFFFFFFFFFFFF + * Server Hashed Password - 301EC144E9C6C4F64C29C01C3E11839C97D6E7D2BC0C5DBC68377B679AE51D4D + * Attestation Type - TPM Quote + * Attestation Type - SAML Assertion + * Client Correlation Value - client 1 + * Server Correlation Value - server 1 + * Batch Count - 1 + */ + uint8 expected[224] = { + 0x42, 0x00, 0x7A, 0x01, 0x00, 0x00, 0x00, 0xD8, + 0x42, 0x00, 0x69, 0x01, 0x00, 0x00, 0x00, 0x20, + 0x42, 0x00, 0x6A, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x6B, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x92, 0x09, 0x00, 0x00, 0x00, 0x08, + 0x00, 0x00, 0x00, 0x00, 0x4F, 0x9A, 0x54, 0xE5, + 0x42, 0x00, 0xC8, 0x01, 0x00, 0x00, 0x00, 0x20, + 0x42, 0x00, 0xC9, 0x08, 0x00, 0x00, 0x00, 0x04, + 0x01, 0x02, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xCA, 0x08, 0x00, 0x00, 0x00, 0x06, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, + 0x42, 0x01, 0x55, 0x08, 0x00, 0x00, 0x00, 0x20, + 0x30, 0x1E, 0xC1, 0x44, 0xE9, 0xC6, 0xC4, 0xF6, + 0x4C, 0x29, 0xC0, 0x1C, 0x3E, 0x11, 0x83, 0x9C, + 0x97, 0xD6, 0xE7, 0xD2, 0xBC, 0x0C, 0x5D, 0xBC, + 0x68, 0x37, 0x7B, 0x67, 0x9A, 0xE5, 0x1D, 0x4D, + 0x42, 0x00, 0xC7, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xC7, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x01, 0x05, 0x07, 0x00, 0x00, 0x00, 0x08, + 0x63, 0x6C, 0x69, 0x65, 0x6E, 0x74, 0x20, 0x31, + 0x42, 0x01, 0x06, 0x07, 0x00, 0x00, 0x00, 0x08, + 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x20, 0x31, + 0x42, 0x00, 0x0D, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[224] = {0}; + KMIP ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_2_0); + + ProtocolVersion pv = {0}; + pv.major = 2; + pv.minor = 0; + + uint8 id[4] = {0x01, 0x02, 0x03, 0x04}; + ByteString ni = {0}; + ni.value = id; + ni.size = ARRAY_LENGTH(id); + + uint8 value[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}; + ByteString nv = {0}; + nv.value = value; + nv.size = ARRAY_LENGTH(value); + + Nonce n = {0}; + n.nonce_id = ∋ + n.nonce_value = &nv; + + uint8 hash[32] = { + 0x30, 0x1E, 0xC1, 0x44, 0xE9, 0xC6, 0xC4, 0xF6, + 0x4C, 0x29, 0xC0, 0x1C, 0x3E, 0x11, 0x83, 0x9C, + 0x97, 0xD6, 0xE7, 0xD2, 0xBC, 0x0C, 0x5D, 0xBC, + 0x68, 0x37, 0x7B, 0x67, 0x9A, 0xE5, 0x1D, 0x4D + }; + ByteString shp = {0}; + shp.value = hash; + shp.size = ARRAY_LENGTH(hash); + + enum attestation_type types[2] = { + KMIP_ATTEST_TPM_QUOTE, + KMIP_ATTEST_SAML_ASSERTION + }; + + TextString ccv = {0}; + ccv.value = "client 1"; + ccv.size = 8; + + TextString scv = {0}; + scv.value = "server 1"; + scv.size = 8; + + ResponseHeader rh = {0}; + kmip_init_response_header(&rh); + + rh.protocol_version = &pv; + rh.time_stamp = 1335514341; + rh.nonce = &n; + rh.server_hashed_password = &shp; + rh.attestation_types = types; + rh.attestation_type_count = ARRAY_LENGTH(types); + rh.batch_count = 1; + + rh.client_correlation_value = &ccv; + rh.server_correlation_value = &scv; + + int result = kmip_encode_response_header(&ctx, &rh); + result = report_encoding_test_result(tracker, &ctx, expected, observed, result, __func__); + + kmip_destroy(&ctx); + return(result); +} + +int +test_decode_response_header_kmip_2_0(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + /* This encoding matches the following set of values: + * Response Header + * Protocol Version + * Protocol Version Major - 2 + * Protocol Version Minor - 0 + * Time Stamp - 1335514341 + * Nonce + * Nonce ID - 0x01020304 + * Nonce Value - 0xFFFFFFFFFFFF + * Server Hashed Password - 301EC144E9C6C4F64C29C01C3E11839C97D6E7D2BC0C5DBC68377B679AE51D4D + * Attestation Type - TPM Quote + * Attestation Type - SAML Assertion + * Client Correlation Value - client 1 + * Server Correlation Value - server 1 + * Batch Count - 1 + */ + uint8 encoding[224] = { + 0x42, 0x00, 0x7A, 0x01, 0x00, 0x00, 0x00, 0xD8, + 0x42, 0x00, 0x69, 0x01, 0x00, 0x00, 0x00, 0x20, + 0x42, 0x00, 0x6A, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x6B, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x92, 0x09, 0x00, 0x00, 0x00, 0x08, + 0x00, 0x00, 0x00, 0x00, 0x4F, 0x9A, 0x54, 0xE5, + 0x42, 0x00, 0xC8, 0x01, 0x00, 0x00, 0x00, 0x20, + 0x42, 0x00, 0xC9, 0x08, 0x00, 0x00, 0x00, 0x04, + 0x01, 0x02, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xCA, 0x08, 0x00, 0x00, 0x00, 0x06, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, + 0x42, 0x01, 0x55, 0x08, 0x00, 0x00, 0x00, 0x20, + 0x30, 0x1E, 0xC1, 0x44, 0xE9, 0xC6, 0xC4, 0xF6, + 0x4C, 0x29, 0xC0, 0x1C, 0x3E, 0x11, 0x83, 0x9C, + 0x97, 0xD6, 0xE7, 0xD2, 0xBC, 0x0C, 0x5D, 0xBC, + 0x68, 0x37, 0x7B, 0x67, 0x9A, 0xE5, 0x1D, 0x4D, + 0x42, 0x00, 0xC7, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0xC7, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x01, 0x05, 0x07, 0x00, 0x00, 0x00, 0x08, + 0x63, 0x6C, 0x69, 0x65, 0x6E, 0x74, 0x20, 0x31, + 0x42, 0x01, 0x06, 0x07, 0x00, 0x00, 0x00, 0x08, + 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x20, 0x31, + 0x42, 0x00, 0x0D, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00 + }; + + KMIP ctx = {0}; + kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_2_0); + + ProtocolVersion pv = {0}; + pv.major = 2; + pv.minor = 0; + + uint8 id[4] = {0x01, 0x02, 0x03, 0x04}; + ByteString ni = {0}; + ni.value = id; + ni.size = ARRAY_LENGTH(id); + + uint8 value[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}; + ByteString nv = {0}; + nv.value = value; + nv.size = ARRAY_LENGTH(value); + + Nonce n = {0}; + n.nonce_id = ∋ + n.nonce_value = &nv; + + uint8 hash[32] = { + 0x30, 0x1E, 0xC1, 0x44, 0xE9, 0xC6, 0xC4, 0xF6, + 0x4C, 0x29, 0xC0, 0x1C, 0x3E, 0x11, 0x83, 0x9C, + 0x97, 0xD6, 0xE7, 0xD2, 0xBC, 0x0C, 0x5D, 0xBC, + 0x68, 0x37, 0x7B, 0x67, 0x9A, 0xE5, 0x1D, 0x4D + }; + ByteString shp = {0}; + shp.value = hash; + shp.size = ARRAY_LENGTH(hash); + + enum attestation_type types[2] = { + KMIP_ATTEST_TPM_QUOTE, + KMIP_ATTEST_SAML_ASSERTION + }; + + TextString ccv = {0}; + ccv.value = "client 1"; + ccv.size = 8; + + TextString scv = {0}; + scv.value = "server 1"; + scv.size = 8; + + ResponseHeader expected = {0}; + kmip_init_response_header(&expected); + + expected.protocol_version = &pv; + expected.time_stamp = 1335514341; + expected.nonce = &n; + expected.server_hashed_password = &shp; + expected.attestation_types = types; + expected.attestation_type_count = ARRAY_LENGTH(types); + expected.batch_count = 1; + + expected.client_correlation_value = &ccv; + expected.server_correlation_value = &scv; + + ResponseHeader observed = {0}; + kmip_init_response_header(&observed); + + int result = kmip_decode_response_header(&ctx, &observed); + int comparison = kmip_compare_response_header(&expected, &observed); + if(!comparison) + { + /* TODO (ph) Reorder these with printing result so that objects are + below function name. + */ + kmip_print_response_header(1, &expected); + kmip_print_response_header(1, &observed); + } + result = report_decoding_test_result(tracker, &ctx, comparison, result, __func__); + + kmip_free_response_header(&ctx, &observed); + kmip_destroy(&ctx); + return(result); +} + +/* +The following tests are taken verbatim from the KMIP 1.1 Test Cases +documentation, available here: + +http://docs.oasis-open.org/kmip/testcases/v1.1/kmip-testcases-v1.1.html +*/ + +int +test_kmip_1_1_test_suite_3_1_1_0_a(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + /* KMIP 1.1 Test Suite - Test 3.1.1.0a */ + uint8 expected[296] = { + 0x42, 0x00, 0x78, 0x01, 0x00, 0x00, 0x01, 0x20, + 0x42, 0x00, 0x77, 0x01, 0x00, 0x00, 0x00, 0x38, + 0x42, 0x00, 0x69, 0x01, 0x00, 0x00, 0x00, 0x20, + 0x42, 0x00, 0x6A, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x6B, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x0D, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x0F, 0x01, 0x00, 0x00, 0x00, 0xD8, + 0x42, 0x00, 0x5C, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x79, 0x01, 0x00, 0x00, 0x00, 0xC0, + 0x42, 0x00, 0x57, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0xA8, + 0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30, + 0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x17, + 0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, + 0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x41, 0x6C, + 0x67, 0x6F, 0x72, 0x69, 0x74, 0x68, 0x6D, 0x00, + 0x42, 0x00, 0x0B, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30, + 0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x14, + 0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, + 0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x4C, 0x65, + 0x6E, 0x67, 0x74, 0x68, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x0B, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30, + 0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x18, + 0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, + 0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x55, 0x73, + 0x61, 0x67, 0x65, 0x20, 0x4D, 0x61, 0x73, 0x6B, + 0x42, 0x00, 0x0B, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[296] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_1); + + /* TODO (ph) If protocol version omitted, pull from context? */ + struct protocol_version pv = {0}; + pv.major = 1; + pv.minor = 1; + + struct request_header rh = {0}; + kmip_init_request_header(&rh); + + rh.protocol_version = &pv; + rh.batch_count = 1; + + struct attribute a[3] = {0}; + for(int i = 0; i < 3; i++) + { + kmip_init_attribute(&a[i]); + } + + enum cryptographic_algorithm algorithm = KMIP_CRYPTOALG_AES; + a[0].type = KMIP_ATTR_CRYPTOGRAPHIC_ALGORITHM; + a[0].value = &algorithm; + + int32 length = 128; + a[1].type = KMIP_ATTR_CRYPTOGRAPHIC_LENGTH; + a[1].value = &length; + + int32 mask = KMIP_CRYPTOMASK_ENCRYPT | KMIP_CRYPTOMASK_DECRYPT; + a[2].type = KMIP_ATTR_CRYPTOGRAPHIC_USAGE_MASK; + a[2].value = &mask; + + struct template_attribute ta = {0}; + ta.attributes = a; + ta.attribute_count = ARRAY_LENGTH(a); + + struct create_request_payload crp = {0}; + crp.object_type = KMIP_OBJTYPE_SYMMETRIC_KEY; + crp.template_attribute = &ta; + + struct request_batch_item rbi = {0}; + kmip_init_request_batch_item(&rbi); + rbi.operation = KMIP_OP_CREATE; + rbi.request_payload = &crp; + + struct request_message rm = {0}; + rm.request_header = &rh; + rm.batch_items = &rbi; + rm.batch_count = 1; + + int result = kmip_encode_request_message(&ctx, &rm); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_kmip_1_1_test_suite_3_1_1_0_b(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + /* KMIP 1.1 Test Suite - Test 3.1.1.0b */ + uint8 expected[200] = { + 0x42, 0x00, 0x7B, 0x01, 0x00, 0x00, 0x00, 0xC0, + 0x42, 0x00, 0x7A, 0x01, 0x00, 0x00, 0x00, 0x48, + 0x42, 0x00, 0x69, 0x01, 0x00, 0x00, 0x00, 0x20, + 0x42, 0x00, 0x6A, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x6B, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x92, 0x09, 0x00, 0x00, 0x00, 0x08, + 0x00, 0x00, 0x00, 0x00, 0x4F, 0x9A, 0x54, 0xE5, + 0x42, 0x00, 0x0D, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x0F, 0x01, 0x00, 0x00, 0x00, 0x68, + 0x42, 0x00, 0x5C, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x7F, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x7C, 0x01, 0x00, 0x00, 0x00, 0x40, + 0x42, 0x00, 0x57, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, + 0x66, 0x62, 0x34, 0x62, 0x35, 0x62, 0x39, 0x63, + 0x2D, 0x36, 0x31, 0x38, 0x38, 0x2D, 0x34, 0x63, + 0x36, 0x33, 0x2D, 0x38, 0x31, 0x34, 0x32, 0x2D, + 0x66, 0x65, 0x39, 0x63, 0x33, 0x32, 0x38, 0x31, + 0x32, 0x39, 0x66, 0x63, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[200] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0); + + struct protocol_version pv = {0}; + pv.major = 1; + pv.minor = 1; + + struct response_header rh = {0}; + kmip_init_response_header(&rh); + + rh.protocol_version = &pv; + rh.time_stamp = 1335514341; + rh.batch_count = 1; + + struct text_string uuid = {0}; + uuid.value = "fb4b5b9c-6188-4c63-8142-fe9c328129fc"; + uuid.size = 36; + + struct create_response_payload crp = {0}; + crp.object_type = KMIP_OBJTYPE_SYMMETRIC_KEY; + crp.unique_identifier = &uuid; + + struct response_batch_item rbi = {0}; + rbi.operation = KMIP_OP_CREATE; + rbi.result_status = KMIP_STATUS_SUCCESS; + rbi.response_payload = &crp; + + struct response_message rm = {0}; + rm.response_header = &rh; + rm.batch_items = &rbi; + rm.batch_count = 1; + + int result = kmip_encode_response_message(&ctx, &rm); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_kmip_1_1_test_suite_3_1_1_1_a(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + /* KMIP 1.1 Test Suite - Test 3.1.1.1a */ + uint8 expected[152] = { + 0x42, 0x00, 0x78, 0x01, 0x00, 0x00, 0x00, 0x90, + 0x42, 0x00, 0x77, 0x01, 0x00, 0x00, 0x00, 0x38, + 0x42, 0x00, 0x69, 0x01, 0x00, 0x00, 0x00, 0x20, + 0x42, 0x00, 0x6A, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x6B, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x0D, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x0F, 0x01, 0x00, 0x00, 0x00, 0x48, + 0x42, 0x00, 0x5C, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x79, 0x01, 0x00, 0x00, 0x00, 0x30, + 0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, + 0x66, 0x62, 0x34, 0x62, 0x35, 0x62, 0x39, 0x63, + 0x2D, 0x36, 0x31, 0x38, 0x38, 0x2D, 0x34, 0x63, + 0x36, 0x33, 0x2D, 0x38, 0x31, 0x34, 0x32, 0x2D, + 0x66, 0x65, 0x39, 0x63, 0x33, 0x32, 0x38, 0x31, + 0x32, 0x39, 0x66, 0x63, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[152] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_1); + + struct protocol_version pv = {0}; + pv.major = 1; + pv.minor = 1; + + struct request_header rh = {0}; + kmip_init_request_header(&rh); + + rh.protocol_version = &pv; + rh.batch_count = 1; + + struct text_string uuid = {0}; + uuid.value = "fb4b5b9c-6188-4c63-8142-fe9c328129fc"; + uuid.size = 36; + + struct destroy_request_payload drp = {0}; + drp.unique_identifier = &uuid; + + struct request_batch_item rbi = {0}; + kmip_init_request_batch_item(&rbi); + rbi.operation = KMIP_OP_DESTROY; + rbi.request_payload = &drp; + + struct request_message rm = {0}; + rm.request_header = &rh; + rm.batch_items = &rbi; + rm.batch_count = 1; + + int result = kmip_encode_request_message(&ctx, &rm); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_kmip_1_1_test_suite_3_1_1_1_b(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + /* KMIP 1.1 Test Suite - Test 3.1.1.1b */ + uint8 expected[184] = { + 0x42, 0x00, 0x7B, 0x01, 0x00, 0x00, 0x00, 0xB0, + 0x42, 0x00, 0x7A, 0x01, 0x00, 0x00, 0x00, 0x48, + 0x42, 0x00, 0x69, 0x01, 0x00, 0x00, 0x00, 0x20, + 0x42, 0x00, 0x6A, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x6B, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x92, 0x09, 0x00, 0x00, 0x00, 0x08, + 0x00, 0x00, 0x00, 0x00, 0x4F, 0x9A, 0x54, 0xE5, + 0x42, 0x00, 0x0D, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x0F, 0x01, 0x00, 0x00, 0x00, 0x58, + 0x42, 0x00, 0x5C, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x7F, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x7C, 0x01, 0x00, 0x00, 0x00, 0x30, + 0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, + 0x66, 0x62, 0x34, 0x62, 0x35, 0x62, 0x39, 0x63, + 0x2D, 0x36, 0x31, 0x38, 0x38, 0x2D, 0x34, 0x63, + 0x36, 0x33, 0x2D, 0x38, 0x31, 0x34, 0x32, 0x2D, + 0x66, 0x65, 0x39, 0x63, 0x33, 0x32, 0x38, 0x31, + 0x32, 0x39, 0x66, 0x63, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[184] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_1); + + struct protocol_version pv = {0}; + pv.major = 1; + pv.minor = 1; + + struct response_header rh = {0}; + kmip_init_response_header(&rh); + + rh.protocol_version = &pv; + rh.time_stamp = 1335514341; + rh.batch_count = 1; + + struct text_string uuid = {0}; + uuid.value = "fb4b5b9c-6188-4c63-8142-fe9c328129fc"; + uuid.size = 36; + + struct destroy_response_payload drp = {0}; + drp.unique_identifier = &uuid; + + struct response_batch_item rbi = {0}; + rbi.operation = KMIP_OP_DESTROY; + rbi.result_status = KMIP_STATUS_SUCCESS; + rbi.response_payload = &drp; + + struct response_message rm = {0}; + rm.response_header = &rh; + rm.batch_items = &rbi; + rm.batch_count = 1; + + int result = kmip_encode_response_message(&ctx, &rm); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_kmip_1_1_test_suite_3_1_3_2_a(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + /* KMIP 1.1 Test Suite - Test 3.1.3.2a */ + uint8 expected[152] = { + 0x42, 0x00, 0x78, 0x01, 0x00, 0x00, 0x00, 0x90, + 0x42, 0x00, 0x77, 0x01, 0x00, 0x00, 0x00, 0x38, + 0x42, 0x00, 0x69, 0x01, 0x00, 0x00, 0x00, 0x20, + 0x42, 0x00, 0x6A, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x6B, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x0D, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x0F, 0x01, 0x00, 0x00, 0x00, 0x48, + 0x42, 0x00, 0x5C, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x79, 0x01, 0x00, 0x00, 0x00, 0x30, + 0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, + 0x34, 0x39, 0x61, 0x31, 0x63, 0x61, 0x38, 0x38, + 0x2D, 0x36, 0x62, 0x65, 0x61, 0x2D, 0x34, 0x66, + 0x62, 0x32, 0x2D, 0x62, 0x34, 0x35, 0x30, 0x2D, + 0x37, 0x65, 0x35, 0x38, 0x38, 0x30, 0x32, 0x63, + 0x33, 0x30, 0x33, 0x38, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[152] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_1); + + struct protocol_version pv = {0}; + pv.major = 1; + pv.minor = 1; + + struct request_header rh = {0}; + kmip_init_request_header(&rh); + + rh.protocol_version = &pv; + rh.batch_count = 1; + + struct text_string uuid = {0}; + uuid.value = "49a1ca88-6bea-4fb2-b450-7e58802c3038"; + uuid.size = 36; + + struct get_request_payload grp = {0}; + grp.unique_identifier = &uuid; + + struct request_batch_item rbi = {0}; + kmip_init_request_batch_item(&rbi); + rbi.operation = KMIP_OP_GET; + rbi.request_payload = &grp; + + struct request_message rm = {0}; + rm.request_header = &rh; + rm.batch_items = &rbi; + rm.batch_count = 1; + + int result = kmip_encode_request_message(&ctx, &rm); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +int +test_kmip_1_1_test_suite_3_1_3_2_b(TestTracker *tracker) +{ + TRACK_TEST(tracker); + + uint8 expected[304] = { + 0x42, 0x00, 0x7B, 0x01, 0x00, 0x00, 0x01, 0x28, + 0x42, 0x00, 0x7A, 0x01, 0x00, 0x00, 0x00, 0x48, + 0x42, 0x00, 0x69, 0x01, 0x00, 0x00, 0x00, 0x20, + 0x42, 0x00, 0x6A, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x6B, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x92, 0x09, 0x00, 0x00, 0x00, 0x08, + 0x00, 0x00, 0x00, 0x00, 0x4F, 0x9A, 0x54, 0xE7, + 0x42, 0x00, 0x0D, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x0F, 0x01, 0x00, 0x00, 0x00, 0xD0, + 0x42, 0x00, 0x5C, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x7F, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x7C, 0x01, 0x00, 0x00, 0x00, 0xA8, + 0x42, 0x00, 0x57, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, + 0x34, 0x39, 0x61, 0x31, 0x63, 0x61, 0x38, 0x38, + 0x2D, 0x36, 0x62, 0x65, 0x61, 0x2D, 0x34, 0x66, + 0x62, 0x32, 0x2D, 0x62, 0x34, 0x35, 0x30, 0x2D, + 0x37, 0x65, 0x35, 0x38, 0x38, 0x30, 0x32, 0x63, + 0x33, 0x30, 0x33, 0x38, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x8F, 0x01, 0x00, 0x00, 0x00, 0x60, + 0x42, 0x00, 0x40, 0x01, 0x00, 0x00, 0x00, 0x58, + 0x42, 0x00, 0x42, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x45, 0x01, 0x00, 0x00, 0x00, 0x20, + 0x42, 0x00, 0x43, 0x08, 0x00, 0x00, 0x00, 0x18, + 0x73, 0x67, 0x57, 0x80, 0x51, 0x01, 0x2A, 0x6D, + 0x13, 0x4A, 0x85, 0x5E, 0x25, 0xC8, 0xCD, 0x5E, + 0x4C, 0xA1, 0x31, 0x45, 0x57, 0x29, 0xD3, 0xC8, + 0x42, 0x00, 0x28, 0x05, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x2A, 0x02, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x00, 0x00, 0xA8, 0x00, 0x00, 0x00, 0x00 + }; + + uint8 observed[304] = {0}; + struct kmip ctx = {0}; + kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_1); + + struct protocol_version pv = {0}; + pv.major = 1; + pv.minor = 1; + + struct response_header rh = {0}; + kmip_init_response_header(&rh); + + rh.protocol_version = &pv; + rh.time_stamp = 1335514343; + rh.batch_count = 1; + + struct text_string uuid = {0}; + uuid.value = "49a1ca88-6bea-4fb2-b450-7e58802c3038"; + uuid.size = 36; + + uint8 value[24] = { + 0x73, 0x67, 0x57, 0x80, 0x51, 0x01, 0x2A, 0x6D, + 0x13, 0x4A, 0x85, 0x5E, 0x25, 0xC8, 0xCD, 0x5E, + 0x4C, 0xA1, 0x31, 0x45, 0x57, 0x29, 0xD3, 0xC8 + }; + + struct byte_string v = {0}; + v.value = value; + v.size = ARRAY_LENGTH(value); + + struct key_value kv = {0}; + kv.key_material = &v; + + struct key_block kb = {0}; + kb.key_format_type = KMIP_KEYFORMAT_RAW; + kb.key_value = &kv; + kb.cryptographic_algorithm = KMIP_CRYPTOALG_TRIPLE_DES; + kb.cryptographic_length = 168; + + struct symmetric_key key = {0}; + key.key_block = &kb; + + struct get_response_payload grp = {0}; + grp.object_type = KMIP_OBJTYPE_SYMMETRIC_KEY; + grp.unique_identifier = &uuid; + grp.object = &key; + + struct response_batch_item rbi = {0}; + rbi.operation = KMIP_OP_GET; + rbi.result_status = KMIP_STATUS_SUCCESS; + rbi.response_payload = &grp; + + struct response_message rm = {0}; + rm.response_header = &rh; + rm.batch_items = &rbi; + rm.batch_count = 1; + + int result = kmip_encode_response_message(&ctx, &rm); + result = report_encoding_test_result( + tracker, + &ctx, + expected, + observed, + result, + __func__); + kmip_destroy(&ctx); + return(result); +} + +/* Test Harness */ + +int +run_tests(void) +{ + TestTracker tracker = {0}; + + printf("Tests\n"); + printf("=====\n"); + + printf("\nUtility Tests\n"); + printf("-------------\n"); + test_linked_list_pop(&tracker); + test_linked_list_push(&tracker); + test_linked_list_enqueue(&tracker); + test_buffer_bytes_left(&tracker); + test_peek_tag(&tracker); + test_is_attribute_tag(&tracker); + test_get_enum_string_index(&tracker); + test_check_enum_value_protection_storage_masks(&tracker); + test_init_protocol_version(&tracker); + test_init_request_batch_item(&tracker); + test_deep_copy_int32(&tracker); + test_deep_copy_text_string(&tracker); + test_deep_copy_name(&tracker); + test_deep_copy_attribute(&tracker); + + printf("\nKMIP 1.0 Feature Tests\n"); + printf("----------------------\n"); + test_buffer_full_and_resize(&tracker); + test_is_tag_next(&tracker); + test_get_num_items_next(&tracker); + test_get_num_items_next_with_partial_item(&tracker); + test_get_num_items_next_with_mismatch_item(&tracker); + test_get_num_items_next_with_no_matches(&tracker); + test_get_num_items_next_with_non_structures(&tracker); + + printf("\n"); + test_decode_int8_be(&tracker); + test_decode_int32_be(&tracker); + test_decode_int64_be(&tracker); + test_decode_integer(&tracker); + test_decode_long(&tracker); + test_decode_enum(&tracker); + test_decode_bool(&tracker); + test_decode_text_string(&tracker); + test_decode_byte_string(&tracker); + test_decode_date_time(&tracker); + test_decode_interval(&tracker); + test_decode_name(&tracker); + test_decode_attribute_unique_identifier(&tracker); + test_decode_attribute_name(&tracker); + test_decode_attribute_object_type(&tracker); + test_decode_attribute_cryptographic_algorithm(&tracker); + test_decode_attribute_cryptographic_length(&tracker); + test_decode_attribute_operation_policy_name(&tracker); + test_decode_attribute_cryptographic_usage_mask(&tracker); + test_decode_attribute_state(&tracker); + test_decode_template_attribute(&tracker); + test_decode_protocol_version(&tracker); + test_decode_key_material_byte_string(&tracker); + test_decode_key_material_transparent_symmetric_key(&tracker); + test_decode_key_value(&tracker); + test_decode_key_value_with_attributes(&tracker); + test_decode_cryptographic_parameters(&tracker); + test_decode_encryption_key_information(&tracker); + test_decode_mac_signature_key_information(&tracker); + test_decode_key_wrapping_data(&tracker); + test_decode_key_block_key_value_byte_string(&tracker); + test_decode_key_block_key_value_structure(&tracker); + test_decode_symmetric_key(&tracker); + test_decode_public_key(&tracker); + test_decode_private_key(&tracker); + test_decode_key_wrapping_specification(&tracker); + test_decode_create_request_payload(&tracker); + test_decode_create_response_payload(&tracker); + test_decode_create_response_payload_with_template_attribute(&tracker); + test_decode_get_request_payload(&tracker); + test_decode_get_response_payload(&tracker); + test_decode_destroy_request_payload(&tracker); + test_decode_destroy_response_payload(&tracker); + test_decode_response_batch_item_get_payload(&tracker); + test_decode_username_password_credential(&tracker); + test_decode_credential_username_password_credential(&tracker); + test_decode_authentication_username_password_credential(&tracker); + test_decode_request_header(&tracker); + test_decode_response_header(&tracker); + test_decode_request_batch_item_get_payload(&tracker); + test_decode_request_message_get(&tracker); + test_decode_response_message_get(&tracker); + + printf("\n"); + test_encode_integer(&tracker); + test_encode_long(&tracker); + test_encode_enum(&tracker); + test_encode_bool(&tracker); + test_encode_text_string(&tracker); + test_encode_byte_string(&tracker); + test_encode_date_time(&tracker); + test_encode_interval(&tracker); + test_encode_name(&tracker); + test_encode_attribute_unique_identifier(&tracker); + test_encode_attribute_name(&tracker); + test_encode_attribute_object_type(&tracker); + test_encode_attribute_cryptographic_algorithm(&tracker); + test_encode_attribute_cryptographic_length(&tracker); + test_encode_attribute_operation_policy_name(&tracker); + test_encode_attribute_cryptographic_usage_mask(&tracker); + test_encode_attribute_state(&tracker); + test_encode_protocol_version(&tracker); + test_encode_cryptographic_parameters(&tracker); + test_encode_encryption_key_information(&tracker); + test_encode_mac_signature_key_information(&tracker); + test_encode_key_wrapping_data(&tracker); + test_encode_key_material_byte_string(&tracker); + test_encode_key_material_transparent_symmetric_key(&tracker); + test_encode_key_value(&tracker); + test_encode_key_value_with_attributes(&tracker); + test_encode_key_block_key_value_byte_string(&tracker); + test_encode_key_block_key_value_structure(&tracker); + test_encode_symmetric_key(&tracker); + test_encode_public_key(&tracker); + test_encode_private_key(&tracker); + test_encode_key_wrapping_specification(&tracker); + test_encode_create_request_payload(&tracker); + test_encode_create_response_payload(&tracker); + test_encode_create_response_payload_with_template_attribute(&tracker); + test_encode_get_request_payload(&tracker); + test_encode_get_request_payload_with_format_compression(&tracker); + test_encode_get_request_payload_with_wrapping_spec(&tracker); + test_encode_get_response_payload(&tracker); + test_encode_destroy_request_payload(&tracker); + test_encode_destroy_response_payload(&tracker); + test_encode_username_password_credential(&tracker); + test_encode_credential_username_password_credential(&tracker); + test_encode_authentication_username_password_credential(&tracker); + test_encode_request_header(&tracker); + test_encode_response_header(&tracker); + test_encode_request_batch_item_get_payload(&tracker); + test_encode_response_batch_item_get_payload(&tracker); + test_encode_request_message_get(&tracker); + test_encode_response_message_get(&tracker); + test_encode_template_attribute(&tracker); + + printf("\nKMIP 1.1 Feature Tests\n"); + printf("----------------------\n"); + test_decode_device_credential(&tracker); + test_decode_key_wrapping_data_with_encoding_option(&tracker); + + printf("\n"); + test_encode_device_credential(&tracker); + test_encode_key_wrapping_data_with_encoding_option(&tracker); + test_encode_key_wrapping_specification_with_encoding_option(&tracker); + + printf("\nKMIP 1.1 Test Suite Test Cases\n"); + printf("------------------------------\n"); + test_kmip_1_1_test_suite_3_1_1_0_a(&tracker); + test_kmip_1_1_test_suite_3_1_1_0_b(&tracker); + test_kmip_1_1_test_suite_3_1_1_1_a(&tracker); + test_kmip_1_1_test_suite_3_1_1_1_b(&tracker); + test_kmip_1_1_test_suite_3_1_3_2_a(&tracker); + test_kmip_1_1_test_suite_3_1_3_2_b(&tracker); + + printf("\nKMIP 1.2 Feature Tests\n"); + printf("----------------------\n"); + test_decode_nonce(&tracker); + test_decode_attestation_credential(&tracker); + test_decode_response_header_with_attestation_details(&tracker); + test_decode_cryptographic_parameters_with_digital_signature_fields(&tracker); + + printf("\n"); + test_encode_nonce(&tracker); + test_encode_attestation_credential(&tracker); + test_encode_request_header_with_attestation_details(&tracker); + test_encode_response_header_with_attestation_details(&tracker); + test_encode_cryptographic_parameters_with_digital_signature_fields(&tracker); + + printf("\nKMIP 1.4 Feature Tests\n"); + printf("----------------------\n"); + test_decode_cryptographic_parameters_with_mask_fields(&tracker); + test_decode_response_header_with_correlation_values(&tracker); + + printf("\n"); + test_encode_cryptographic_parameters_with_mask_fields(&tracker); + test_encode_get_request_payload_with_wrap_type(&tracker); + test_encode_request_header_with_correlation_values(&tracker); + test_encode_response_header_with_correlation_values(&tracker); + + printf("\nKMIP 2.0 Feature Tests\n"); + printf("----------------------\n"); + test_decode_protection_storage_masks(&tracker); + test_decode_attributes(&tracker); + test_decode_attributes_with_invalid_kmip_version(&tracker); + test_decode_attribute_v2_unique_identifier(&tracker); + test_decode_attribute_v2_name(&tracker); + test_decode_attribute_v2_object_type(&tracker); + test_decode_attribute_v2_cryptographic_algorithm(&tracker); + test_decode_attribute_v2_cryptographic_length(&tracker); + test_decode_attribute_v2_cryptographic_usage_mask(&tracker); + test_decode_attribute_v2_state(&tracker); + test_decode_attribute_v2_unsupported_attribute(&tracker); + test_decode_create_request_payload_kmip_2_0(&tracker); + test_decode_request_batch_item_get_payload_kmip_2_0(&tracker); + test_decode_response_header_kmip_2_0(&tracker); + + printf("\n"); + test_encode_protection_storage_masks(&tracker); + test_encode_attributes(&tracker); + test_encode_attributes_with_invalid_kmip_version(&tracker); + test_encode_attribute_v2_unique_identifier(&tracker); + test_encode_attribute_v2_name(&tracker); + test_encode_attribute_v2_object_type(&tracker); + test_encode_attribute_v2_cryptographic_algorithm(&tracker); + test_encode_attribute_v2_cryptographic_length(&tracker); + test_encode_attribute_v2_cryptographic_usage_mask(&tracker); + test_encode_attribute_v2_state(&tracker); + test_encode_attribute_v2_unsupported_attribute(&tracker); + test_encode_create_request_payload_kmip_2_0(&tracker); + test_encode_request_batch_item_get_payload_kmip_2_0(&tracker); + test_encode_response_header_kmip_2_0(&tracker); + + printf("\nSummary\n"); + printf("================\n"); + printf("Total tests: %u\n", tracker.test_count); + printf(" PASS: %u\n", tracker.tests_passed); + printf(" FAILURE: %u\n", tracker.tests_failed); + + return(tracker.tests_failed); +} + +void +print_help(const char *app) +{ + printf("Usage: %s [flag] ...\n\n", app); + printf("Flags:\n"); + printf("-h : print this help info\n"); + printf("-i : run the test suite forever\n"); +} + +int +parse_arguments(int argc, + char **argv, + int *print_usage, + int *run_forever) +{ + for(int i = 1; i < argc; i++) + { + if(strncmp(argv[i], "-h", 2) == 0) + { + *print_usage = 1; + } + else if(strncmp(argv[i], "-i", 2) == 0) + { + *run_forever = 1; + } + else + { + printf("Invalid option: '%s'\n", argv[i]); + print_help(argv[0]); + return(-1); + } + } + + return(0); +} + +int +main(int argc, char **argv) +{ + int print_usage = 0; + int run_forever = 0; + + int error = parse_arguments(argc, argv, &print_usage, &run_forever); + if(error) + { + return(error); + } + if(print_usage) + { + print_help(argv[0]); + return(0); + } + + int results = 0; + if(run_forever) + { + while(1) + { + run_tests(); + } + } + else + { + results = run_tests(); + } + + return(results); +} -- cgit v1.2.3