libmongocrypt-helper 1.7.0.0.1001 → 1.7.4.0.1000

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

@@ -0,0 +1,148 @@
+/*
+ * 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 "kms_message/kms_kmip_response_parser.h"
+
+#include "kms_endian_private.h"
+#include "kms_kmip_response_parser_private.h"
+#include "kms_message_private.h"
+#include "kms_request_str.h"
+
+struct _kms_kmip_response_parser_t {
+   uint32_t first_len;
+   uint32_t bytes_fed;
+   kms_request_str_t *buf;
+   bool failed;
+   char error[512];
+};
+
+/* FIRST_LENGTH_OFFSET is the offset of the first Length in a TTLV sequence. The
+ * sequence is: Tag (3 bytes), Type (1 byte), Length (4 bytes), Value (Length
+ * bytes). */
+static const uint32_t FIRST_LENGTH_OFFSET = 4;
+
+/* _parser_destroy destroys the fields of parser, but not the parser itself. */
+static void
+_parser_destroy (kms_kmip_response_parser_t *parser)
+{
+   kms_request_str_destroy (parser->buf);
+}
+
+/* _parser_init initializes the members of parser. */
+static void
+_parser_init (kms_kmip_response_parser_t *parser)
+{
+   memset (parser, 0, sizeof (*parser));
+   parser->buf = kms_request_str_new ();
+}
+
+kms_response_parser_t *
+kms_kmip_response_parser_new (void *reserved)
+{
+   kms_response_parser_t *parser = kms_response_parser_new ();
+
+   parser->kmip = malloc (sizeof (kms_kmip_response_parser_t));
+   _parser_init (parser->kmip);
+
+   return parser;
+}
+
+int32_t
+kms_kmip_response_parser_wants_bytes (const kms_kmip_response_parser_t *parser,
+                                      int32_t max)
+{
+   int32_t wants_bytes;
+   uint32_t total_len;
+   uint32_t want_bytes_pending;
+   if (parser->bytes_fed < KMS_KMIP_RESPONSE_PARSER_FIRST_LENGTH) {
+      wants_bytes =
+         KMS_KMIP_RESPONSE_PARSER_FIRST_LENGTH - (int32_t) parser->bytes_fed;
+   } else {
+      KMS_ASSERT (parser->first_len <=
+                  UINT32_MAX - KMS_KMIP_RESPONSE_PARSER_FIRST_LENGTH);
+      total_len = parser->first_len + KMS_KMIP_RESPONSE_PARSER_FIRST_LENGTH;
+      KMS_ASSERT (total_len >= parser->bytes_fed);
+      want_bytes_pending = total_len - parser->bytes_fed;
+      KMS_ASSERT (want_bytes_pending <= (uint32_t) INT32_MAX);
+      wants_bytes = (int32_t) want_bytes_pending;
+   }
+   if (max < wants_bytes) {
+      return max;
+   }
+   return wants_bytes;
+}
+
+bool
+kms_kmip_response_parser_feed (kms_kmip_response_parser_t *parser,
+                               const uint8_t *buf,
+                               uint32_t len)
+{
+   kms_request_str_append_chars (parser->buf, (char *) buf, len);
+   parser->bytes_fed += len;
+
+   if (parser->first_len > 0) {
+      if (parser->bytes_fed >
+          parser->first_len + KMS_KMIP_RESPONSE_PARSER_FIRST_LENGTH) {
+         KMS_ERROR (parser, "KMIP parser was fed too much data");
+         return false;
+      }
+   } else if (parser->first_len == 0 &&
+              parser->bytes_fed >= KMS_KMIP_RESPONSE_PARSER_FIRST_LENGTH) {
+      uint32_t temp;
+      memcpy (&temp, parser->buf->str + FIRST_LENGTH_OFFSET, sizeof (uint32_t));
+      parser->first_len = KMS_UINT32_FROM_BE (temp);
+   }
+   return true;
+}
+
+kms_response_t *
+kms_kmip_response_parser_get_response (kms_kmip_response_parser_t *parser)
+{
+   kms_response_t *res;
+
+   if (kms_kmip_response_parser_wants_bytes (parser, 1) != 0) {
+      KMS_ERROR (parser, "KMIP parser does not have a complete message");
+      return NULL;
+   }
+
+   res = calloc (1, sizeof (kms_response_t));
+   res->provider = KMS_REQUEST_PROVIDER_KMIP;
+   res->kmip.len = (uint32_t) parser->buf->len;
+   res->kmip.data = (uint8_t *) kms_request_str_detach (parser->buf);
+   parser->buf = NULL;
+
+   /* Reinitialize for reuse. */
+   _parser_destroy (parser);
+   _parser_init (parser);
+   return res;
+}
+
+const char *
+kms_kmip_response_parser_error (const kms_kmip_response_parser_t *parser)
+{
+   return parser->failed ? parser->error : NULL;
+}
+
+void
+kms_kmip_response_parser_destroy (kms_kmip_response_parser_t *parser)
+{
+   if (!parser) {
+      return;
+   }
+
+   _parser_destroy (parser);
+   free (parser);
+}

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

@@ -0,0 +1,55 @@
+/*
+ * 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.
+ */
+
+#ifndef KMS_KMIP_RESPONSE_PARSER_PRIVATE_H
+#define KMS_KMIP_RESPONSE_PARSER_PRIVATE_H
+
+#include "kms_message/kms_response.h"
+
+#include <stdbool.h>
+#include <stdint.h>
+
+/* kms_kmip_response_parser_t is a private type used for parsing a KMIP
+ * response. */
+typedef struct _kms_kmip_response_parser_t kms_kmip_response_parser_t;
+
+/* KMS_KMIP_RESPONSE_PARSER_FIRST_LENGTH is the number of bytes needed by the
+ * parser to determine the total length of the message being parsed.
+ * It includes the first Length in a TTLV sequence. The sequence is: Tag (3
+ * bytes), Type (1 byte), Length (4 bytes), Value (Length bytes). */
+#define KMS_KMIP_RESPONSE_PARSER_FIRST_LENGTH 8
+
+int32_t
+kms_kmip_response_parser_wants_bytes (const kms_kmip_response_parser_t *parser,
+                                      int32_t max);
+
+bool
+kms_kmip_response_parser_feed (kms_kmip_response_parser_t *parser,
+                               const uint8_t *buf,
+                               uint32_t len);
+
+/* kms_kmip_response_parser_get_response returns a kms_response_t and resets the
+ * parser. */
+kms_response_t *
+kms_kmip_response_parser_get_response (kms_kmip_response_parser_t *parser);
+
+void
+kms_kmip_response_parser_destroy (kms_kmip_response_parser_t *parser);
+
+const char *
+kms_kmip_response_parser_error (const kms_kmip_response_parser_t *parser);
+
+#endif /* KMS_KMIP_RESPONSE_PARSER_PRIVATE_H */

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

@@ -0,0 +1,77 @@
+/*
+ * 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.
+ */
+
+#ifndef KMS_KMIP_RESULT_REASON_PRIVATE_H
+#define KMS_KMIP_RESULT_REASON_PRIVATE_H
+
+#include "kms_message/kms_message_defines.h"
+
+/* clang-format off */
+#define KMS_XMACRO                                                                             \
+   KMS_X (ItemNotFound, "Item Not Found", 0x00000001)                                          \
+   KMS_X (ResponseTooLarge, "Response Too Large", 0x00000002)                                  \
+   KMS_X (AuthenticationNotSuccessful, "Authentication Not Successful", 0x00000003)            \
+   KMS_X (InvalidMessage, "Invalid Message", 0x00000004)                                       \
+   KMS_X (OperationNotSupported, "Operation Not Supported", 0x00000005)                        \
+   KMS_X (MissingData, "Missing Data", 0x00000006)                                             \
+   KMS_X (InvalidField, "Invalid Field", 0x00000007)                                           \
+   KMS_X (FeatureNotSupported, "Feature Not Supported", 0x00000008)                            \
+   KMS_X (OperationCanceledByRequester, "Operation Canceled By Requester", 0x00000009)         \
+   KMS_X (CryptographicFailure, "Cryptographic Failure", 0x0000000A)                           \
+   KMS_X (IllegalOperation, "Illegal Operation", 0x0000000B)                                   \
+   KMS_X (PermissionDenied, "Permission Denied", 0x0000000C)                                   \
+   KMS_X (Objectarchived, "Object archived", 0x0000000D)                                       \
+   KMS_X (IndexOutofBounds, "Index Out of Bounds", 0x0000000E)                                 \
+   KMS_X (ApplicationNamespaceNotSupported, "Application Namespace Not Supported", 0x0000000F) \
+   KMS_X (KeyFormatTypeNotSupported, "Key Format Type Not Supported", 0x00000010)              \
+   KMS_X (KeyCompressionTypeNotSupported, "Key Compression Type Not Supported", 0x00000011)    \
+   KMS_X (EncodingOptionError, "Encoding Option Error", 0x00000012)                            \
+   KMS_X (KeyValueNotPresent, "Key Value Not Present", 0x00000013)                             \
+   KMS_X (AttestationRequired, "Attestation Required", 0x00000014)                             \
+   KMS_X (AttestationFailed, "Attestation Failed", 0x00000015)                                 \
+   KMS_X (Sensitive, "Sensitive", 0x00000016)                                                  \
+   KMS_X (NotExtractable, "Not Extractable", 0x00000017)                                       \
+   KMS_X (ObjectAlreadyExists, "Object Already Exists", 0x00000018)                            \
+   KMS_X_LAST (GeneralFailure, "General Failure", 0x00000100)
+/* clang-format on */
+
+/* Generate an enum with each result_reason value. */
+#define KMS_X(RESULT_REASON, STR, VAL) KMIP_RESULT_REASON_##RESULT_REASON = VAL,
+#define KMS_X_LAST(RESULT_REASON, STR, VAL) \
+   KMIP_RESULT_REASON_##RESULT_REASON = VAL
+typedef enum { KMS_XMACRO } kmip_result_reason_t;
+#undef KMS_X
+#undef KMS_X_LAST
+
+#define KMS_X(RESULT_REASON, STR, VAL)      \
+   case KMIP_RESULT_REASON_##RESULT_REASON: \
+      return STR;
+#define KMS_X_LAST KMS_X
+static KMS_MSG_INLINE const char *
+kmip_result_reason_to_string (kmip_result_reason_t result_reason)
+{
+   switch (result_reason) {
+   default:
+      return "Unknown KMIP result reason";
+      KMS_XMACRO
+   }
+}
+#undef KMS_X
+#undef KMS_X_LAST
+
+#undef KMS_XMACRO
+
+#endif /* KMS_KMIP_RESULT_REASON_PRIVATE_H */

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

@@ -0,0 +1,54 @@
+/*
+ * 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.
+ */
+
+#ifndef KMS_KMIP_RESULT_STATUS_PRIVATE_H
+#define KMS_KMIP_RESULT_STATUS_PRIVATE_H
+
+#include "kms_message/kms_message_defines.h"
+
+#define KMS_XMACRO                                           \
+   KMS_X (OperationSuccess, "Success", 0x00000000)           \
+   KMS_X (OperationFailed, "Operation Failed", 0x00000001)   \
+   KMS_X (OperationPending, "Operation Pending", 0x00000002) \
+   KMS_X_LAST (OperationUndone, "Operation Undone", 0x00000003)
+
+/* Generate an enum with each result_status value. */
+#define KMS_X(RESULT_STATUS, STR, VAL) KMIP_RESULT_STATUS_##RESULT_STATUS = VAL,
+#define KMS_X_LAST(RESULT_STATUS, STR, VAL) \
+   KMIP_RESULT_STATUS_##RESULT_STATUS = VAL
+typedef enum { KMS_XMACRO } kmip_result_status_t;
+#undef KMS_X
+#undef KMS_X_LAST
+
+#define KMS_X(RESULT_STATUS, STR, VAL)      \
+   case KMIP_RESULT_STATUS_##RESULT_STATUS: \
+      return STR;
+#define KMS_X_LAST KMS_X
+static KMS_MSG_INLINE const char *
+kmip_result_status_to_string (kmip_result_status_t result_status)
+{
+   switch (result_status) {
+   default:
+      return "Unknown KMIP result status";
+      KMS_XMACRO
+   }
+}
+#undef KMS_X
+#undef KMS_X_LAST
+
+#undef KMS_XMACRO
+
+#endif /* KMS_KMIP_RESULT_STATUS_PRIVATE_H */