libmongocrypt-helper 1.7.0.0.1001 → 1.7.4.0.1000

data/ext/libmongocrypt/libmongocrypt/kms-message/test/encrypt/encrypt.sreq

@@ -0,0 +1,9 @@
+POST / HTTP/1.1
+Content-Length:45
+Content-Type:application/x-amz-json-1.1
+Host:service.us-east-1.amazonaws.com
+X-Amz-Date:20150830T123600Z
+X-Amz-Target:TrentService.Encrypt
+Authorization: AWS4-HMAC-SHA256 Credential=AKIDEXAMPLE/20150830/us-east-1/service/aws4_request, SignedHeaders=content-length;content-type;host;x-amz-date;x-amz-target, Signature=28d8a139a4a7da0bd7082979fa938ce20514e0500cdd441fd46f702ae3d3cfd2
+
+{"Plaintext": "Zm9vYmFy", "KeyId": "alias/1"}

data/ext/libmongocrypt/libmongocrypt/kms-message/test/example-chunked-response.bin

@@ -0,0 +1,20 @@
+HTTP/1.1 200 OK
+Content-Type: application/json; charset=UTF-8
+Vary: X-Origin
+Vary: Referer
+Date: Thu, 24 Sep 2020 14:21:44 GMT
+Server: scaffolding on HTTPServer2
+Cache-Control: private
+X-XSS-Protection: 0
+X-Frame-Options: SAMEORIGIN
+X-Content-Type-Options: nosniff
+Alt-Svc: h3-Q050=":443"; ma=2592000,h3-29=":443"; ma=2592000,h3-27=":443"; ma=2592000,h3-T051=":443"; ma=2592000,h3-T050=":443"; ma=2592000,h3-Q046=":443"; ma=2592000,h3-Q043=":443"; ma=2592000,quic=":443"; ma=2592000; v="46,43"
+Accept-Ranges: none
+Vary: Origin,Accept-Encoding
+Connection: close
+Transfer-Encoding: chunked
+
+105
+{"access_token":"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA","expires_in":3599,"token_type":"Bearer"}
+0
+

data/ext/libmongocrypt/libmongocrypt/kms-message/test/example-multi-chunked-response.bin

@@ -0,0 +1,22 @@
+HTTP/1.1 200 OK
+Content-Type: application/json; charset=UTF-8
+Vary: X-Origin
+Vary: Referer
+Date: Thu, 24 Sep 2020 14:21:44 GMT
+Server: scaffolding on HTTPServer2
+Cache-Control: private
+X-XSS-Protection: 0
+X-Frame-Options: SAMEORIGIN
+X-Content-Type-Options: nosniff
+Alt-Svc: h3-Q050=":443"; ma=2592000,h3-29=":443"; ma=2592000,h3-27=":443"; ma=2592000,h3-T051=":443"; ma=2592000,h3-T050=":443"; ma=2592000,h3-Q046=":443"; ma=2592000,h3-Q043=":443"; ma=2592000,quic=":443"; ma=2592000; v="46,43"
+Accept-Ranges: none
+Vary: Origin,Accept-Encoding
+Connection: close
+Transfer-Encoding: chunked
+
+DD
+{"access_token":"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
+28
+"expires_in":3599,"token_type":"Bearer"}
+0
+

data/ext/libmongocrypt/libmongocrypt/kms-message/test/example-response.bin

@@ -0,0 +1,6 @@
+HTTP/1.1 200 OK
+x-amzn-RequestId: deeb35e5-4ecb-4bf1-9af5-84a54ff0af0e
+Content-Type: application/x-amz-json-1.1
+Content-Length: 319
+
+{"CiphertextBlob":"AQICAHifzrL6n/3uqZyz+z1bJj80DhqPcSAibAaIoYc+HOVP6QEplwbM0wpvU5zsQG/1SBKvAAAAZDBiBgkqhkiG9w0BBwagVTBTAgEAME4GCSqGSIb3DQEHATAeBglghkgBZQMEAS4wEQQM5syMJE7RodxDaqYqAgEQgCHMFCnFso4Lih0CNbLT1kiET0hQyzjgoa9733353GQkGlM=","KeyId":"arn:aws:kms:us-east-1:524754917239:key/bd05530b-0a7f-4fbd-8362-ab3667370db0"}

data/ext/libmongocrypt/libmongocrypt/kms-message/test/host/host.sreq

@@ -0,0 +1,4 @@
+POST / HTTP/1.1
+Host:foo-service.foo-region.amazonaws.com
+X-Amz-Date:20150830T123600Z
+Authorization: AWS4-HMAC-SHA256 Credential=foo-akid/20150830/foo-region/foo-service/aws4_request, SignedHeaders=host;x-amz-date, Signature=8b264695a2fd7fe28b309c611e0770da5a4c5ca0c040209941f78d773d9297b2

data/ext/libmongocrypt/libmongocrypt/kms-message/test/multibyte/multibyte.creq

@@ -0,0 +1,10 @@
+GET
+/%E2%82%AC/
+euro=%E2%82%AC
+content-length:4
+host:€.€.amazonaws.com
+x-amz-date:20150830T123600Z
+€:€asdf€
+
+content-length;host;x-amz-date;€
+5bf858e4b892817978d798623768af7080d99ded72501cf15374e12861725f12

data/ext/libmongocrypt/libmongocrypt/kms-message/test/multibyte/multibyte.sreq

@@ -0,0 +1,8 @@
+GET /€/?euro=€ HTTP/1.1
+Content-Length:4
+Host:€.€.amazonaws.com
+X-Amz-Date:20150830T123600Z
+€:€asdf€
+Authorization: AWS4-HMAC-SHA256 Credential=AKIDEXAMPLE/20150830/€/€/aws4_request, SignedHeaders=content-length;host;x-amz-date;€, Signature=88d2d4b0639c6b6db1ce366d2578b8407562caa905fc375fdf1ddb7f0b789f5b
+
+€

data/ext/libmongocrypt/libmongocrypt/kms-message/test/test_kmip_reader_writer.c

@@ -0,0 +1,485 @@
+/*
+ * Copyright 2021-present MongoDB, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "test_kms_assert.h"
+#include "test_kms_util.h"
+
+#include "kms_kmip_reader_writer_private.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef struct {
+   char *desc;
+   char *expected_hex;
+} kms_kmip_writer_test_case_t;
+
+static void
+kms_kmip_writer_test_evaluate (kmip_writer_t *writer,
+                               const char *expected_hex_in,
+                               char *desc)
+{
+   char *expected_hex;
+   const uint8_t *actual_buf;
+   size_t actual_len;
+   char *actual_hex;
+
+   expected_hex = copy_and_filter_hex (expected_hex_in);
+   actual_buf = kmip_writer_get_buffer (writer, &actual_len);
+   actual_hex = data_to_hex (actual_buf, actual_len);
+
+   if (0 != strcmp (expected_hex, actual_hex)) {
+      fprintf (stderr,
+               "expected '%s' but got '%s' for test description: %s\n",
+               expected_hex,
+               actual_hex,
+               desc);
+      abort ();
+   }
+
+   free (actual_hex);
+   free (expected_hex);
+}
+
+void
+kms_kmip_writer_test (void)
+{
+   kmip_writer_t *writer;
+
+   /* The following test cases come from section 9.1.2 of
+    * http://docs.oasis-open.org/kmip/spec/v1.4/os/kmip-spec-v1.4-os.html */
+   writer = kmip_writer_new ();
+   kmip_writer_write_integer (writer, KMIP_TAG_CompromiseDate, 8);
+   kms_kmip_writer_test_evaluate (
+      writer,
+      "42 00 20 | 02 | 00 00 00 04 | 00 00 00 08 00 00 00 00",
+      "An Integer containing the decimal value 8");
+   kmip_writer_destroy (writer);
+
+   writer = kmip_writer_new ();
+   kmip_writer_write_long_integer (
+      writer, KMIP_TAG_CompromiseDate, 123456789000000000LL);
+   kms_kmip_writer_test_evaluate (
+      writer,
+      "42 00 20 | 03 | 00 00 00 08 | 01 B6 9B 4B A5 74 92 00",
+      "A Long Integer containing the decimal value 123456789000000000");
+   kmip_writer_destroy (writer);
+
+   /* BigInteger is not implemented. */
+
+   writer = kmip_writer_new ();
+   kmip_writer_write_enumeration (writer, KMIP_TAG_CompromiseDate, 255);
+   kms_kmip_writer_test_evaluate (
+      writer,
+      "42 00 20 | 05 | 00 00 00 04 | 00 00 00 FF 00 00 00 00",
+      "An Enumeration with value 255");
+   kmip_writer_destroy (writer);
+
+   /* Boolean is not implemented. */
+
+   writer = kmip_writer_new ();
+   kmip_writer_write_string (
+      writer, KMIP_TAG_CompromiseDate, "Hello World", 11);
+   kms_kmip_writer_test_evaluate (writer,
+                                  "42 00 20 | 07 | 00 00 00 0B | 48 65 6C 6C "
+                                  "6F 20 57 6F 72 6C 64 00 00 00 00 00",
+                                  "A Text String with the value 'Hello World'");
+   kmip_writer_destroy (writer);
+
+   writer = kmip_writer_new ();
+   kmip_writer_write_bytes (writer, KMIP_TAG_CompromiseDate, "\01\02\03", 3);
+   kms_kmip_writer_test_evaluate (
+      writer,
+      "42 00 20 | 08 | 00 00 00 03 | 01 02 03 00 00 00 00 00",
+      "A Byte String with the value { 0x01, 0x02, 0x03 }");
+   kmip_writer_destroy (writer);
+
+   writer = kmip_writer_new ();
+   kmip_writer_write_datetime (
+      writer, KMIP_TAG_CompromiseDate, 0x0000000047DA67F8LL);
+   kms_kmip_writer_test_evaluate (
+      writer,
+      "42 00 20 | 09 | 00 00 00 08 | 00 00 00 00 47 DA 67 F8",
+      "A Date-Time, containing the value for Friday, March 14, 2008, 11:56:40 "
+      "GMT");
+   kmip_writer_destroy (writer);
+
+   /* Interval is not implemented. */
+
+   writer = kmip_writer_new ();
+   kmip_writer_begin_struct (writer, KMIP_TAG_CompromiseDate);
+   kmip_writer_write_enumeration (
+      writer, KMIP_TAG_ApplicationSpecificInformation, 254);
+   kmip_writer_write_integer (writer, KMIP_TAG_ArchiveDate, 255);
+   kmip_writer_close_struct (writer);
+   kms_kmip_writer_test_evaluate (
+      writer,
+      "42 00 20 | 01 | 00 00 00 20 | 42 00 04 | 05 | 00 00 00 04 | 00 00 00 FE "
+      "00 00 00 00 | 42 00 05 | 02 | 00 00 00 04 | 00 00 00 FF 00 00 00 00",
+      "A Structure containing an Enumeration, value 254, followed by an "
+      "Integer, value 255, having tags 420004 and 420005 respectively");
+   kmip_writer_destroy (writer);
+}
+
+void
+kms_kmip_reader_test (void)
+{
+   uint8_t *data;
+   size_t datalen;
+   kmip_reader_t *reader;
+   kmip_tag_type_t tag;
+   kmip_item_type_t type;
+   uint32_t length;
+   int32_t i32;
+   int64_t i64;
+   uint32_t u32;
+   uint8_t *ptr;
+
+   /* The following test cases come from section 9.1.2 of
+    * http://docs.oasis-open.org/kmip/spec/v1.4/os/kmip-spec-v1.4-os.html */
+   /* An Integer containing the decimal value 8 */
+   data = hex_to_data ("42 00 20 | 02 | 00 00 00 04 | 00 00 00 08 00 00 00 00",
+                       &datalen);
+   reader = kmip_reader_new (data, datalen);
+   ASSERT (kmip_reader_read_tag (reader, &tag));
+   ASSERT (tag == KMIP_TAG_CompromiseDate);
+   ASSERT (kmip_reader_read_type (reader, &type));
+   ASSERT (type == KMIP_ITEM_TYPE_Integer);
+   ASSERT (kmip_reader_read_length (reader, &length));
+   ASSERT (length == 4);
+   ASSERT (kmip_reader_read_integer (reader, &i32));
+   ASSERT (i32 == 8);
+   ASSERT (!kmip_reader_has_data (reader));
+   kmip_reader_destroy (reader);
+   free (data);
+
+   /* A Long Integer containing the decimal value 123456789000000000 */
+   data = hex_to_data ("42 00 20 | 03 | 00 00 00 08 | 01 B6 9B 4B A5 74 92 00",
+                       &datalen);
+   reader = kmip_reader_new (data, datalen);
+   ASSERT (kmip_reader_read_tag (reader, &tag));
+   ASSERT (tag == KMIP_TAG_CompromiseDate);
+   ASSERT (kmip_reader_read_type (reader, &type));
+   ASSERT (type == KMIP_ITEM_TYPE_LongInteger);
+   ASSERT (kmip_reader_read_length (reader, &length));
+   ASSERT (length == 8);
+   ASSERT (kmip_reader_read_long_integer (reader, &i64));
+   ASSERT (i64 == 123456789000000000LL);
+   ASSERT (!kmip_reader_has_data (reader));
+   kmip_reader_destroy (reader);
+   free (data);
+
+   /* Big Integer is not implemented. */
+
+   /* An Enumeration with value 255 */
+   data = hex_to_data ("42 00 20 | 05 | 00 00 00 04 | 00 00 00 FF 00 00 00 00",
+                       &datalen);
+   reader = kmip_reader_new (data, datalen);
+   ASSERT (kmip_reader_read_tag (reader, &tag));
+   ASSERT (tag == KMIP_TAG_CompromiseDate);
+   ASSERT (kmip_reader_read_type (reader, &type));
+   ASSERT (type == KMIP_ITEM_TYPE_Enumeration);
+   ASSERT (kmip_reader_read_length (reader, &length));
+   ASSERT (length == 4);
+   ASSERT (kmip_reader_read_enumeration (reader, &u32));
+   ASSERT (u32 == 255);
+   ASSERT (!kmip_reader_has_data (reader));
+   kmip_reader_destroy (reader);
+   free (data);
+
+   /* Boolean is not implemented */
+
+   /* A Text String with the value 'Hello World' */
+   data = hex_to_data ("42 00 20 | 07 | 00 00 00 0B | 48 65 6C "
+                       "6C 6F 20 57 6F 72 6C 64 00 00 00 00 00",
+                       &datalen);
+   reader = kmip_reader_new (data, datalen);
+   ASSERT (kmip_reader_read_tag (reader, &tag));
+   ASSERT (tag == KMIP_TAG_CompromiseDate);
+   ASSERT (kmip_reader_read_type (reader, &type));
+   ASSERT (type == KMIP_ITEM_TYPE_TextString);
+   ASSERT (kmip_reader_read_length (reader, &length));
+   ASSERT (length == 11);
+   ASSERT (kmip_reader_read_string (reader, &ptr, length));
+   ASSERT (0 == strncmp ("Hello World", (const char *) ptr, length));
+   ASSERT (!kmip_reader_has_data (reader));
+   kmip_reader_destroy (reader);
+   free (data);
+
+   /* A Byte String with the value { 0x01, 0x02, 0x03 } */
+   data = hex_to_data ("42 00 20 | 08 | 00 00 00 03 | 01 02 03 00 00 00 00 00",
+                       &datalen);
+   reader = kmip_reader_new (data, datalen);
+   ASSERT (kmip_reader_read_tag (reader, &tag));
+   ASSERT (tag == KMIP_TAG_CompromiseDate);
+   ASSERT (kmip_reader_read_type (reader, &type));
+   ASSERT (type == KMIP_ITEM_TYPE_ByteString);
+   ASSERT (kmip_reader_read_length (reader, &length));
+   ASSERT (length == 3);
+   ASSERT (kmip_reader_read_bytes (reader, &ptr, length));
+   ASSERT (0 == strncmp ("\01\02\03", (const char *) ptr, length));
+   ASSERT (!kmip_reader_has_data (reader));
+   kmip_reader_destroy (reader);
+   free (data);
+
+   /* A Date-Time, containing the value for Friday, March 14, 2008, 11:56:40 GMT
+    */
+   data = hex_to_data ("42 00 20 | 09 | 00 00 00 08 | 00 00 00 00 47 DA 67 F8",
+                       &datalen);
+   reader = kmip_reader_new (data, datalen);
+   ASSERT (kmip_reader_read_tag (reader, &tag));
+   ASSERT (tag == KMIP_TAG_CompromiseDate);
+   ASSERT (kmip_reader_read_type (reader, &type));
+   ASSERT (type == KMIP_ITEM_TYPE_DateTime);
+   ASSERT (kmip_reader_read_length (reader, &length));
+   ASSERT (length == 8);
+   kmip_reader_read_long_integer (reader, &i64);
+   ASSERT (i64 == 0x47DA67F8);
+   ASSERT (!kmip_reader_has_data (reader));
+   kmip_reader_destroy (reader);
+   free (data);
+
+   /* Interval is not implemented. */
+
+   /* A Structure containing an Enumeration, value 254, followed by an Integer,
+    * value 255, having tags 420004 and 420005 respectively */
+   data = hex_to_data (
+      "42 00 20 | 01 | 00 00 00 20 | 42 00 04 | 05 | 00 00 00 04 | 00 00 00 FE "
+      "00 00 00 00 | 42 00 05 | 02 | 00 00 00 04 | 00 00 00 FF 00 00 00 00",
+      &datalen);
+   reader = kmip_reader_new (data, datalen);
+   ASSERT (kmip_reader_read_tag (reader, &tag));
+   ASSERT (tag == KMIP_TAG_CompromiseDate);
+   ASSERT (kmip_reader_read_type (reader, &type));
+   ASSERT (type == KMIP_ITEM_TYPE_Structure);
+   ASSERT (kmip_reader_read_length (reader, &length));
+   ASSERT (length == 0x20);
+
+   ASSERT (kmip_reader_read_tag (reader, &tag));
+   ASSERT (tag == KMIP_TAG_ApplicationSpecificInformation);
+   ASSERT (kmip_reader_read_type (reader, &type));
+   ASSERT (type == KMIP_ITEM_TYPE_Enumeration);
+   ASSERT (kmip_reader_read_length (reader, &length));
+   ASSERT (length == 4);
+   ASSERT (kmip_reader_read_enumeration (reader, &u32));
+   ASSERT (u32 == 254);
+
+   ASSERT (kmip_reader_read_tag (reader, &tag));
+   ASSERT (tag == KMIP_TAG_ArchiveDate);
+   ASSERT (kmip_reader_read_type (reader, &type));
+   ASSERT (type == KMIP_ITEM_TYPE_Integer);
+   ASSERT (kmip_reader_read_length (reader, &length));
+   ASSERT (length == 4);
+   ASSERT (kmip_reader_read_integer (reader, &i32));
+   ASSERT (i32 == 255);
+
+   ASSERT (!kmip_reader_has_data (reader));
+   kmip_reader_destroy (reader);
+   free (data);
+}
+
+void
+kms_kmip_reader_negative_int_test (void)
+{
+   uint8_t *data;
+   size_t datalen;
+   kmip_reader_t *reader;
+   kmip_tag_type_t tag;
+   kmip_item_type_t type;
+   uint32_t length;
+   int32_t i32;
+
+   /* Test reading the integer -1. */
+   data = hex_to_data ("42 00 20 | 02 | 00 00 00 04 | FF FF FF FF 00 00 00 00",
+                       &datalen);
+   reader = kmip_reader_new (data, datalen);
+   ASSERT (kmip_reader_read_tag (reader, &tag));
+   ASSERT (tag == KMIP_TAG_CompromiseDate);
+   ASSERT (kmip_reader_read_type (reader, &type));
+   ASSERT (type == KMIP_ITEM_TYPE_Integer);
+   ASSERT (kmip_reader_read_length (reader, &length));
+   ASSERT (length == 4);
+   ASSERT (kmip_reader_read_integer (reader, &i32));
+   ASSERT (i32 == -1);
+   ASSERT (!kmip_reader_has_data (reader));
+   kmip_reader_destroy (reader);
+   free (data);
+
+   /* Test reading the integer INT32_MIN (-2^31). */
+   data = hex_to_data ("42 00 20 | 02 | 00 00 00 04 | 80 00 00 00 00 00 00 00",
+                       &datalen);
+   reader = kmip_reader_new (data, datalen);
+   ASSERT (kmip_reader_read_tag (reader, &tag));
+   ASSERT (tag == KMIP_TAG_CompromiseDate);
+   ASSERT (kmip_reader_read_type (reader, &type));
+   ASSERT (type == KMIP_ITEM_TYPE_Integer);
+   ASSERT (kmip_reader_read_length (reader, &length));
+   ASSERT (length == 4);
+   ASSERT (kmip_reader_read_integer (reader, &i32));
+   ASSERT (i32 == INT32_MIN);
+   ASSERT (!kmip_reader_has_data (reader));
+   kmip_reader_destroy (reader);
+   free (data);
+}
+
+void
+kms_kmip_reader_find_test (void)
+{
+   uint8_t *data;
+   size_t datalen;
+   kmip_reader_t *reader;
+   bool found;
+   size_t pos = 0;
+   size_t len = 0;
+
+   /* A Structure containing an Enumeration, value 254, followed by an Integer,
+    * value 255, having tags 420004 and 420005 respectively */
+   data = hex_to_data (
+      "42 00 20 | 01 | 00 00 00 20 | 42 00 04 | 05 | 00 00 00 04 | 00 00 00 FE "
+      "00 00 00 00 | 42 00 05 | 02 | 00 00 00 04 | 00 00 00 FF 00 00 00 00",
+      &datalen);
+
+   reader = kmip_reader_new (data, datalen);
+
+   /* Finds the top-level Structure. */
+   found = kmip_reader_find (
+      reader, KMIP_TAG_CompromiseDate, KMIP_ITEM_TYPE_Structure, &pos, &len);
+   ASSERT (found);
+   ASSERT (pos == 0);
+   ASSERT (len == 32);
+
+   /* Mismatched tag does not find the Structure. */
+   found = kmip_reader_find (
+      reader, KMIP_TAG_ActivationDate, KMIP_ITEM_TYPE_Structure, &pos, &len);
+   ASSERT (!found);
+
+   /* Mismatched type does not find the Structure. */
+   found = kmip_reader_find (
+      reader, KMIP_TAG_CompromiseDate, KMIP_ITEM_TYPE_Integer, &pos, &len);
+   ASSERT (!found);
+
+   /* Values nested within the Structure are not found. */
+   found = kmip_reader_find (reader,
+                             KMIP_TAG_ApplicationSpecificInformation,
+                             KMIP_ITEM_TYPE_Enumeration,
+                             &pos,
+                             &len);
+   ASSERT (!found);
+
+   kmip_reader_destroy (reader);
+   free (data);
+}
+
+void
+kms_kmip_reader_find_and_recurse_test (void)
+{
+   uint8_t *data;
+   size_t datalen;
+   kmip_reader_t *reader;
+   bool found;
+   size_t pos = 0;
+   size_t len = 0;
+
+   /* A Structure containing an Enumeration, value 254, followed by an Integer,
+    * value 255, having tags 420004 and 420005 respectively */
+   data = hex_to_data (
+      "42 00 20 | 01 | 00 00 00 20 | 42 00 04 | 05 | 00 00 00 04 | 00 00 00 FE "
+      "00 00 00 00 | 42 00 05 | 02 | 00 00 00 04 | 00 00 00 FF 00 00 00 00",
+      &datalen);
+
+   reader = kmip_reader_new (data, datalen);
+   ASSERT (kmip_reader_find_and_recurse (reader, KMIP_TAG_CompromiseDate));
+
+   /* Values nested within the Structure are found. */
+   found = kmip_reader_find (reader,
+                             KMIP_TAG_ApplicationSpecificInformation,
+                             KMIP_ITEM_TYPE_Enumeration,
+                             &pos,
+                             &len);
+   ASSERT (found);
+   ASSERT (pos == 8);
+   ASSERT (len == 4);
+
+   kmip_reader_destroy (reader);
+   free (data);
+}
+
+void
+kms_kmip_reader_find_and_read_enum_test (void)
+{
+   uint8_t *data;
+   size_t datalen;
+   kmip_reader_t *reader;
+   bool found;
+   uint32_t value;
+
+   /* An Integer, value 255, followed by an Enumeration, value 254 having tags
+    * 420005 and 420004 respectively. */
+   data = hex_to_data (
+      "42 00 05 | 02 | 00 00 00 04 | 00 00 00 FF 00 00 00 00 | 42 00 04 | 05 | "
+      "00 00 00 04 | 00 00 00 FE 00 00 00 00",
+      &datalen);
+
+   reader = kmip_reader_new (data, datalen);
+
+   found = kmip_reader_find_and_read_enum (
+      reader, KMIP_TAG_ApplicationSpecificInformation, &value);
+   ASSERT (found);
+   ASSERT (value == 254);
+
+   /* The Integer should not be found. */
+   found =
+      kmip_reader_find_and_read_enum (reader, KMIP_TAG_ArchiveDate, &value);
+   ASSERT (!found);
+
+   kmip_reader_destroy (reader);
+   free (data);
+}
+
+void
+kms_kmip_reader_find_and_read_bytes_test (void)
+{
+   uint8_t *data;
+   size_t datalen;
+   kmip_reader_t *reader;
+   bool found;
+   uint8_t *outptr;
+   size_t outlen;
+
+   /* An Integer, value 255, followed by ByteString of value 0x1122 having tags
+    * 420005 and 420004 respectively. */
+   data = hex_to_data (
+      "42 00 05 | 02 | 00 00 00 04 | 00 00 00 FF 00 00 00 00 | 42 00 04 | 08 | "
+      "00 00 00 02 | 11 22 00 00 00 00 00 00",
+      &datalen);
+
+   reader = kmip_reader_new (data, datalen);
+
+   found = kmip_reader_find_and_read_bytes (
+      reader, KMIP_TAG_ApplicationSpecificInformation, &outptr, &outlen);
+   ASSERT (found);
+   ASSERT (outlen == 2);
+   ASSERT (outptr[0] == 0x11);
+   ASSERT (outptr[1] == 0x22);
+
+   /* The Integer should not be found. */
+   found = kmip_reader_find_and_read_bytes (
+      reader, KMIP_TAG_ArchiveDate, &outptr, &outlen);
+   ASSERT (!found);
+
+   kmip_reader_destroy (reader);
+   free (data);
+}