libmongocrypt-helper 1.7.0.0.1001 → 1.7.4.0.1000

data/ext/libmongocrypt/libmongocrypt/kms-message/src/kms_request_str.h

@@ -0,0 +1,89 @@
+/*
+ * Copyright 2018-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.
+ */
+
+#ifndef KMS_MESSAGE_KMS_REQUEST_STR_H
+#define KMS_MESSAGE_KMS_REQUEST_STR_H
+
+#include "kms_message/kms_message.h"
+#include "kms_crypto.h"
+
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <string.h>
+
+typedef struct {
+   char *str;
+   size_t len;
+   size_t size;
+} kms_request_str_t;
+
+KMS_MSG_EXPORT (kms_request_str_t *)
+kms_request_str_new (void);
+KMS_MSG_EXPORT (kms_request_str_t *)
+kms_request_str_new_from_chars (const char *chars, ssize_t len);
+KMS_MSG_EXPORT (kms_request_str_t *)
+kms_request_str_wrap (char *chars, ssize_t len);
+KMS_MSG_EXPORT (void)
+kms_request_str_destroy (kms_request_str_t *str);
+KMS_MSG_EXPORT (char *)
+kms_request_str_detach (kms_request_str_t *str);
+KMS_MSG_EXPORT (bool)
+kms_request_str_reserve (kms_request_str_t *str, size_t size);
+KMS_MSG_EXPORT (kms_request_str_t *)
+kms_request_str_dup (kms_request_str_t *str);
+KMS_MSG_EXPORT (void)
+kms_request_str_set_chars (kms_request_str_t *str,
+                           const char *chars,
+                           ssize_t len);
+KMS_MSG_EXPORT (bool)
+kms_request_str_ends_with (kms_request_str_t *str, kms_request_str_t *suffix);
+KMS_MSG_EXPORT (void)
+kms_request_str_append (kms_request_str_t *str, kms_request_str_t *appended);
+KMS_MSG_EXPORT (void)
+kms_request_str_append_char (kms_request_str_t *str, char c);
+KMS_MSG_EXPORT (void)
+kms_request_str_append_chars (kms_request_str_t *str,
+                              const char *appended,
+                              ssize_t len);
+KMS_MSG_EXPORT (void)
+kms_request_str_append_newline (kms_request_str_t *str);
+KMS_MSG_EXPORT (void)
+kms_request_str_append_lowercase (kms_request_str_t *str,
+                                  kms_request_str_t *appended);
+KMS_MSG_EXPORT (void)
+kms_request_str_appendf (kms_request_str_t *str, const char *format, ...);
+KMS_MSG_EXPORT (void)
+kms_request_strdupf (kms_request_str_t *str, const char *format, ...);
+KMS_MSG_EXPORT (void)
+kms_request_str_append_escaped (kms_request_str_t *str,
+                                kms_request_str_t *appended,
+                                bool escape_slash);
+KMS_MSG_EXPORT (void)
+kms_request_str_append_stripped (kms_request_str_t *str,
+                                 kms_request_str_t *appended);
+KMS_MSG_EXPORT (bool)
+kms_request_str_append_hashed (_kms_crypto_t *crypto,
+                               kms_request_str_t *str,
+                               kms_request_str_t *appended);
+KMS_MSG_EXPORT (bool)
+kms_request_str_append_hex (kms_request_str_t *str,
+                            unsigned char *data,
+                            size_t len);
+KMS_MSG_EXPORT (kms_request_str_t *)
+kms_request_str_path_normalized (kms_request_str_t *str);
+
+#endif // KMS_MESSAGE_KMS_REQUEST_STR_H

data/ext/libmongocrypt/libmongocrypt/kms-message/src/kms_response.c

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2018-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 "kms_message/kms_message.h"
+#include "kms_message_private.h"
+#include "kms_request_str.h"
+
+void
+kms_response_destroy (kms_response_t *response)
+{
+   if (response == NULL) {
+      return;
+   }
+
+   free (response->kmip.data);
+   kms_kv_list_destroy (response->headers);
+   kms_request_str_destroy (response->body);
+   free (response);
+}
+
+const char *
+kms_response_get_body (kms_response_t *response, size_t *len)
+{
+   if (len) {
+      *len = response->body->len;
+   }
+   return response->body->str;
+}
+
+int
+kms_response_get_status (kms_response_t *response)
+{
+   return response->status;
+}
+
+const char *
+kms_response_get_error (const kms_response_t *response)
+{
+   return response->failed ? response->error : NULL;
+}

data/ext/libmongocrypt/libmongocrypt/kms-message/src/kms_response_parser.c

@@ -0,0 +1,408 @@
+#include "kms_message/kms_response_parser.h"
+#include "kms_message_private.h"
+#include "kms_kmip_response_parser_private.h"
+
+#include <errno.h>
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "hexlify.h"
+
+/* destroys the members of parser, but not the parser itself. */
+static void
+_parser_destroy (kms_response_parser_t *parser)
+{
+   kms_request_str_destroy (parser->raw_response);
+   parser->raw_response = NULL;
+   parser->content_length = -1;
+   kms_response_destroy (parser->response);
+   parser->response = NULL;
+   kms_kmip_response_parser_destroy (parser->kmip);
+}
+
+/* initializes the members of parser. */
+static void
+_parser_init (kms_response_parser_t *parser)
+{
+   parser->raw_response = kms_request_str_new ();
+   parser->content_length = -1;
+   parser->response = calloc (1, sizeof (kms_response_t));
+   KMS_ASSERT (parser->response);
+   parser->response->headers = kms_kv_list_new ();
+   parser->state = PARSING_STATUS_LINE;
+   parser->start = 0;
+   parser->failed = false;
+   parser->chunk_size = 0;
+   parser->transfer_encoding_chunked = false;
+   parser->kmip = NULL;
+}
+
+kms_response_parser_t *
+kms_response_parser_new (void)
+{
+   kms_response_parser_t *parser = malloc (sizeof (kms_response_parser_t));
+   KMS_ASSERT (parser);
+
+   _parser_init (parser);
+   return parser;
+}
+
+int
+kms_response_parser_wants_bytes (kms_response_parser_t *parser, int32_t max)
+{
+   if (parser->kmip) {
+      return kms_kmip_response_parser_wants_bytes (parser->kmip, max);
+   }
+   switch (parser->state) {
+   case PARSING_DONE:
+      return 0;
+   case PARSING_STATUS_LINE:
+   case PARSING_HEADER:
+      return max;
+   case PARSING_CHUNK_LENGTH:
+      return max;
+   case PARSING_CHUNK:
+      /* add 2 for trailing \r\n */
+      return (parser->chunk_size + 2) -
+             ((int) parser->raw_response->len - parser->start);
+   case PARSING_BODY:
+      KMS_ASSERT (parser->content_length != -1);
+      return parser->content_length -
+             ((int) parser->raw_response->len - parser->start);
+   default:
+      KMS_ASSERT (false && "Invalid kms_response_parser HTTP state");
+   }
+   return -1;
+}
+
+static bool
+_parse_int (const char *str, int *result)
+{
+   char *endptr = NULL;
+   int64_t long_result;
+
+   errno = 0;
+   long_result = strtol (str, &endptr, 10);
+   if (endptr == str) {
+      /* No digits were parsed. Consider this an error */
+      return false;
+   }
+   if (endptr != NULL && *endptr != '\0') {
+      /* endptr points to the first invalid character. */
+      return false;
+   }
+   if (errno == EINVAL || errno == ERANGE) {
+      return false;
+   }
+   if (long_result > INT32_MAX || long_result < INT32_MIN) {
+      return false;
+   }
+   *result = (int) long_result;
+
+   return true;
+}
+
+/* parse an int from a substring inside of a string. */
+static bool
+_parse_int_from_view (const char *str, int start, int end, int *result)
+{
+   KMS_ASSERT (end >= start);
+   char *num_str = malloc ((size_t) (end - start + 1));
+   KMS_ASSERT (num_str);
+
+   bool ret;
+
+   strncpy (num_str, str + start, (size_t) (end - start));
+   num_str[end - start] = '\0';
+   ret = _parse_int (num_str, result);
+   free (num_str);
+   return ret;
+}
+
+static bool
+_parse_hex_from_view (const char *str, int len, int *result)
+{
+   KMS_ASSERT (len >= 0);
+   *result = unhexlify (str, (size_t) len);
+   if (*result < 0) {
+      return false;
+   }
+   return true;
+}
+
+/* returns true if char is "linear white space". This *ignores* the folding case
+ * of CRLF followed by WSP. See https://stackoverflow.com/a/21072806/774658 */
+static bool
+_is_lwsp (char c)
+{
+   return c == ' ' || c == 0x09 /* HTAB */;
+}
+
+/* parse a header line or status line. */
+static kms_response_parser_state_t
+_parse_line (kms_response_parser_t *parser, int end)
+{
+   int i = parser->start;
+   const char *raw = parser->raw_response->str;
+   kms_response_t *response = parser->response;
+
+   if (parser->state == PARSING_STATUS_LINE) {
+      /* Status-Line = HTTP-Version SP Status-Code SP Reason-Phrase CRLF */
+      int j;
+      int status;
+
+      if (strncmp (raw + i, "HTTP/1.1 ", 9) != 0) {
+         KMS_ERROR (parser, "Could not parse HTTP-Version.");
+         return PARSING_DONE;
+      }
+      i += 9;
+
+      for (j = i; j < end; j++) {
+         if (raw[j] == ' ')
+            break;
+      }
+
+      if (!_parse_int_from_view (raw, i, j, &status)) {
+         KMS_ERROR (parser, "Could not parse Status-Code.");
+         return PARSING_DONE;
+      }
+
+      response->status = status;
+
+      /* ignore the Reason-Phrase. */
+      return PARSING_HEADER;
+   } else if (parser->state == PARSING_HEADER) {
+      /* Treating a header as:
+       * message-header = field-name ":" [ field-value ] CRLF
+       * This is not completely correct, and does not take folding into acct.
+       * See https://tools.ietf.org/html/rfc822#section-3.1
+       */
+      int j;
+      kms_request_str_t *key;
+      kms_request_str_t *val;
+
+      if (i == end) {
+         /* empty line, this signals the start of the body. */
+         if (parser->transfer_encoding_chunked) {
+            return PARSING_CHUNK_LENGTH;
+         }
+         return PARSING_BODY;
+      }
+
+      for (j = i; j < end; j++) {
+         if (raw[j] == ':')
+            break;
+      }
+
+      if (j == end) {
+         KMS_ERROR (parser, "Could not parse header, no colon found.");
+         return PARSING_DONE;
+      }
+
+      key = kms_request_str_new_from_chars (raw + i, j - i);
+
+      i = j + 1;
+      /* remove leading and trailing whitespace from the value. */
+      for (j = i; j < end; j++) {
+         if (!_is_lwsp (raw[j]))
+            break;
+      }
+      i = j;
+
+      /* find the end of the header by backtracking. */
+      for (j = end; j > i; j--) {
+         if (!_is_lwsp (raw[j]))
+            break;
+      }
+
+      if (i == j) {
+         val = kms_request_str_new ();
+      } else {
+         val = kms_request_str_new_from_chars (raw + i, j - i);
+      }
+
+      kms_kv_list_add (response->headers, key, val);
+
+      /* if we have *not* read the Content-Length yet, check. */
+      if (parser->content_length == -1 &&
+          strcmp (key->str, "Content-Length") == 0) {
+         if (!_parse_int (val->str, &parser->content_length)) {
+            KMS_ERROR (parser, "Could not parse Content-Length header.");
+            kms_request_str_destroy (key);
+            kms_request_str_destroy (val);
+            return PARSING_DONE;
+         }
+      }
+
+      if (0 == strcmp (key->str, "Transfer-Encoding")) {
+         if (0 == strcmp (val->str, "chunked")) {
+            parser->transfer_encoding_chunked = true;
+         } else {
+            KMS_ERROR (parser, "Unsupported Transfer-Encoding: %s", val->str);
+            kms_request_str_destroy (key);
+            kms_request_str_destroy (val);
+            return PARSING_DONE;
+         }
+      }
+      kms_request_str_destroy (key);
+      kms_request_str_destroy (val);
+      return PARSING_HEADER;
+   } else if (parser->state == PARSING_CHUNK_LENGTH) {
+      int result = 0;
+
+      if (!_parse_hex_from_view (raw + i, end - i, &result)) {
+         KMS_ERROR (parser, "Failed to parse hex chunk length.");
+         return PARSING_DONE;
+      }
+      parser->chunk_size = result;
+      return PARSING_CHUNK;
+   }
+   return PARSING_DONE;
+}
+
+bool
+kms_response_parser_feed (kms_response_parser_t *parser,
+                          uint8_t *buf,
+                          uint32_t len)
+{
+   kms_request_str_t *raw = parser->raw_response;
+   int curr, body_read, chunk_read;
+
+   if (parser->kmip) {
+      return kms_kmip_response_parser_feed (parser->kmip, buf, len);
+   }
+
+   curr = (int) raw->len;
+   kms_request_str_append_chars (raw, (char *) buf, len);
+   /* process the new data appended. */
+   while (curr < (int) raw->len) {
+      switch (parser->state) {
+      case PARSING_STATUS_LINE:
+      case PARSING_HEADER:
+      case PARSING_CHUNK_LENGTH:
+         /* find the next \r\n. */
+         if (curr && strncmp (raw->str + (curr - 1), "\r\n", 2) == 0) {
+            parser->state = _parse_line (parser, curr - 1);
+            parser->start = curr + 1;
+         }
+         curr++;
+
+         if (parser->state == PARSING_BODY && parser->content_length <= 0) {
+            /* Ok, no Content-Length header, or explicitly 0, so empty body */
+            parser->response->body = kms_request_str_new ();
+            parser->state = PARSING_DONE;
+         }
+         break;
+      case PARSING_BODY:
+         body_read = (int) raw->len - parser->start;
+
+         if (parser->content_length == -1 ||
+             body_read > parser->content_length) {
+            KMS_ERROR (parser, "Unexpected: exceeded content length");
+            return false;
+         }
+
+         /* check if we have the entire body. */
+         if (body_read == parser->content_length) {
+            parser->response->body = kms_request_str_new_from_chars (
+               raw->str + parser->start, parser->content_length);
+            parser->state = PARSING_DONE;
+         }
+
+         curr = (int) raw->len;
+         break;
+      case PARSING_CHUNK:
+         chunk_read = (int) raw->len - parser->start;
+         /* check if we've read the full chunk and the trailing \r\n */
+         if (chunk_read >= parser->chunk_size + 2) {
+            if (!parser->response->body) {
+               parser->response->body = kms_request_str_new ();
+            }
+            kms_request_str_append_chars (parser->response->body,
+                                          raw->str + parser->start,
+                                          parser->chunk_size);
+            curr = parser->start + parser->chunk_size + 2;
+            parser->start = curr;
+            if (parser->chunk_size == 0) {
+               /* last chunk. */
+               parser->state = PARSING_DONE;
+            } else {
+               parser->state = PARSING_CHUNK_LENGTH;
+            }
+         } else {
+            curr = (int) raw->len;
+         }
+         break;
+      case PARSING_DONE:
+         KMS_ERROR (parser, "Unexpected extra HTTP content");
+         return false;
+      default:
+         KMS_ASSERT (false && "Invalid kms_response_parser HTTP state");
+      }
+   }
+
+   if (parser->failed) {
+      return false;
+   }
+   return true;
+}
+
+/* steals the response from the parser. */
+kms_response_t *
+kms_response_parser_get_response (kms_response_parser_t *parser)
+{
+   kms_response_t *response;
+
+   if (parser->kmip) {
+      return kms_kmip_response_parser_get_response (parser->kmip);
+   }
+
+   response = parser->response;
+
+   parser->response = NULL;
+   /* reset the parser. */
+   _parser_destroy (parser);
+   _parser_init (parser);
+   return response;
+}
+
+int
+kms_response_parser_status (kms_response_parser_t *parser)
+{
+   if (!parser) {
+      return 0;
+   }
+
+   if (parser->kmip) {
+      KMS_ERROR (parser, "kms_response_parser_status not applicable to KMIP");
+      return 0;
+   }
+
+   if (!parser->response) {
+      return 0;
+   }
+
+   return parser->response->status;
+}
+
+const char *
+kms_response_parser_error (kms_response_parser_t *parser)
+{
+   if (!parser) {
+      return NULL;
+   }
+
+   if (parser->kmip) {
+      return kms_kmip_response_parser_error (parser->kmip);
+   }
+
+   return parser->error;
+}
+
+void
+kms_response_parser_destroy (kms_response_parser_t *parser)
+{
+   _parser_destroy (parser);
+   free (parser);
+}

data/ext/libmongocrypt/libmongocrypt/kms-message/src/sort.c

@@ -0,0 +1,74 @@
+/*
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Copyright (c) 1992, 1993
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Peter McIlroy.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/**
+ * This code is originally from:
+ * https://github.com/freebsd/freebsd/blob/e7c6cef9514d3bb1f14a30a5ee871231523e43db/lib/libc/stdlib/merge.c
+ */
+
+#include <stddef.h>
+
+/*
+ * This is to avoid out-of-bounds addresses in sorting the
+ * last 4 elements.
+ */
+
+typedef int (*cmp_t) (const void *, const void *);
+#define CMP(x, y) cmp (x, y)
+#define swap(a, b)   \
+   {                 \
+      s = b;         \
+      i = size;      \
+      do {           \
+         tmp = *a;   \
+         *a++ = *s;  \
+         *s++ = tmp; \
+      } while (--i); \
+      a -= size;     \
+   }
+
+void
+insertionsort (unsigned char *a, size_t n, size_t size, cmp_t cmp)
+{
+   unsigned char *ai, *s, *t, *u, tmp;
+   size_t i;
+
+   for (ai = a + size; --n >= 1; ai += size)
+      for (t = ai; t > a; t -= size) {
+         u = t - size;
+         if (CMP (u, t) <= 0)
+            break;
+         swap (u, t);
+      }
+}

data/ext/libmongocrypt/libmongocrypt/kms-message/src/sort.h

@@ -0,0 +1,21 @@
+/*
+ * Copyright 2018-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.
+ */
+
+typedef int (*cmp_t) (const void *, const void *);
+
+void
+insertionsort (unsigned char *a, size_t n, size_t size, cmp_t cmp);

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

@@ -0,0 +1,5 @@
+POST / HTTP/1.1
+Connection:close
+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/content_length/content_length.sreq

@@ -0,0 +1,7 @@
+POST / HTTP/1.1
+Content-Length:11
+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=content-length;host;x-amz-date, Signature=9025f1937fb114f77158a8bf0170e1ec1a9aa29806bc7800ca850966cd32920b
+
+foo-payload

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

@@ -0,0 +1,11 @@
+POST
+/
+
+content-length:234
+content-type:application/x-amz-json-1.1
+host:service.us-east-1.amazonaws.com
+x-amz-date:20150830T123600Z
+x-amz-target:TrentService.Decrypt
+
+content-length;content-type;host;x-amz-date;x-amz-target
+48384de310621c850968f3948bddd004ecf5cae592a24530f778e4d190bd9dbc

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

@@ -0,0 +1,9 @@
+POST / HTTP/1.1
+Content-Length:234
+Content-Type:application/x-amz-json-1.1
+Host:service.us-east-1.amazonaws.com
+X-Amz-Date:20150830T123600Z
+X-Amz-Target:TrentService.Decrypt
+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=977a49f82aa74b38944cbd299880dcc3ec2bbcd953c36b1a19a3cde56f415f31
+
+{"CiphertextBlob": "AQICAHjzjtjUxrr7oc/BHmjyoZGeNk10osSeMGcIUzMNzeDJGwFgMNRznpAfp0NVhCb51fCxAAAAZDBiBgkqhkiG9w0BBwagVTBTAgEAME4GCSqGSIb3DQEHATAeBglghkgBZQMEAS4wEQQMoscSHCU4DuwIHyMJAgEQgCFhA83L4qw2T3PbG3MuM9pFUfTNwP/S4bnEwg6/U5BGGEI="}

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

@@ -0,0 +1,11 @@
+POST
+/
+
+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
+
+content-length;content-type;host;x-amz-date;x-amz-target
+5fc6e5b49ee8c6926b9eeefb69e108be4c8e1cf81d8af8f51c7d5b992afd029c