libmongocrypt-helper 1.7.0.0.1001 → 1.7.4.0.1000

data/ext/libmongocrypt/libmongocrypt/src/mc-optional-private.h

@@ -0,0 +1,124 @@
+/*
+ * Copyright 2022-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 MC_OPTIONAL_PRIVATE_H
+#define MC_OPTIONAL_PRIVATE_H
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#include "./mc-dec128.h"
+#include "./mlib/int128.h"
+
+typedef struct {
+   bool set;
+   int32_t value;
+} mc_optional_int32_t;
+
+#define OPT_I32(val)            \
+   (mc_optional_int32_t)        \
+   {                            \
+      .set = true, .value = val \
+   }
+
+#define OPT_I32_C(val)          \
+   {                            \
+      .set = true, .value = val \
+   }
+
+typedef struct {
+   bool set;
+   uint32_t value;
+} mc_optional_uint32_t;
+
+#define OPT_U32(val)            \
+   (mc_optional_uint32_t)       \
+   {                            \
+      .set = true, .value = val \
+   }
+
+#define OPT_U32_C(val)          \
+   {                            \
+      .set = true, .value = val \
+   }
+
+typedef struct {
+   bool set;
+   int64_t value;
+} mc_optional_int64_t;
+
+#define OPT_I64(val)            \
+   (mc_optional_int64_t)        \
+   {                            \
+      .set = true, .value = val \
+   }
+
+#define OPT_I64_C(val)          \
+   {                            \
+      .set = true, .value = val \
+   }
+
+typedef struct {
+   bool set;
+   uint64_t value;
+} mc_optional_uint64_t;
+
+#define OPT_U64(val)            \
+   (mc_optional_uint64_t)       \
+   {                            \
+      .set = true, .value = val \
+   }
+
+#define OPT_U64_C(val)          \
+   {                            \
+      .set = true, .value = val \
+   }
+
+typedef struct {
+   bool set;
+   double value;
+} mc_optional_double_t;
+
+#define OPT_DOUBLE(val)         \
+   (mc_optional_double_t)       \
+   {                            \
+      .set = true, .value = val \
+   }
+
+#define OPT_DOUBLE_C(val)       \
+   {                            \
+      .set = true, .value = val \
+   }
+
+#if MONGOCRYPT_HAVE_DECIMAL128_SUPPORT
+typedef struct {
+   bool set;
+   mc_dec128 value;
+} mc_optional_dec128_t;
+
+#define OPT_MC_DEC128(...)              \
+   (mc_optional_dec128_t)               \
+   {                                    \
+      .set = true, .value = __VA_ARGS__ \
+   }
+#endif // MONGOCRYPT_HAVE_DECIMAL128_SUPPORT
+
+#define OPT_NULLOPT \
+   {                \
+      .set = false  \
+   }
+
+#endif /* MC_OPTIONAL_PRIVATE_H */

data/ext/libmongocrypt/libmongocrypt/src/mc-range-edge-generation-private.h

@@ -0,0 +1,161 @@
+/*
+ * Copyright 2022-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 MC_RANGE_EDGE_GENERATION_PRIVATE_H
+#define MC_RANGE_EDGE_GENERATION_PRIVATE_H
+
+#include <stddef.h> // size_t
+#include <stdint.h>
+#include "mc-optional-private.h"
+#include "mongocrypt-status-private.h"
+#include "mc-dec128.h"
+#include <mlib/int128.h>
+
+// mc_edges_t represents a list of edges.
+typedef struct _mc_edges_t mc_edges_t;
+
+// mc_edges_get returns edge at an index.
+// Returns NULL if `index` is out of range.
+const char *
+mc_edges_get (mc_edges_t *edges, size_t index);
+
+// mc_edges_len returns the number of represented edges.
+size_t
+mc_edges_len (mc_edges_t *edges);
+
+// mc_edges_destroys frees `edges`.
+void
+mc_edges_destroy (mc_edges_t *edges);
+
+typedef struct {
+   int32_t value;
+   mc_optional_int32_t min;
+   mc_optional_int32_t max;
+   size_t sparsity;
+} mc_getEdgesInt32_args_t;
+
+// mc_getEdgesInt32 implements the Edge Generation algorithm described in
+// SERVER-67751 for int32_t.
+mc_edges_t *
+mc_getEdgesInt32 (mc_getEdgesInt32_args_t args, mongocrypt_status_t *status);
+
+typedef struct {
+   int64_t value;
+   mc_optional_int64_t min;
+   mc_optional_int64_t max;
+   size_t sparsity;
+} mc_getEdgesInt64_args_t;
+
+// mc_getEdgesInt64 implements the Edge Generation algorithm described in
+// SERVER-67751 for int64_t.
+mc_edges_t *
+mc_getEdgesInt64 (mc_getEdgesInt64_args_t args, mongocrypt_status_t *status);
+
+typedef struct {
+   double value;
+   size_t sparsity;
+   mc_optional_double_t min;
+   mc_optional_double_t max;
+   mc_optional_uint32_t precision;
+} mc_getEdgesDouble_args_t;
+
+// mc_getEdgesDouble implements the Edge Generation algorithm described in
+// SERVER-67751 for double.
+mc_edges_t *
+mc_getEdgesDouble (mc_getEdgesDouble_args_t args, mongocrypt_status_t *status);
+
+#if MONGOCRYPT_HAVE_DECIMAL128_SUPPORT
+typedef struct {
+   mc_dec128 value;
+   size_t sparsity;
+   mc_optional_dec128_t min, max;
+   mc_optional_uint32_t precision;
+} mc_getEdgesDecimal128_args_t;
+
+mc_edges_t *
+mc_getEdgesDecimal128 (mc_getEdgesDecimal128_args_t args,
+                       mongocrypt_status_t *status);
+#endif // MONGOCRYPT_HAVE_DECIMAL128_SUPPORT
+
+BSON_STATIC_ASSERT2 (ull_is_u64,
+                     sizeof (uint64_t) == sizeof (unsigned long long));
+
+// count_leading_zeros_u64 returns the number of leading 0 bits of `in`.
+static inline size_t
+mc_count_leading_zeros_u64 (uint64_t in)
+{
+#ifdef __has_builtin
+#if __has_builtin(__builtin_clzll)
+   unsigned long long ull = in;
+   return (size_t) (in ? __builtin_clzll (ull) : 64);
+#endif
+#endif
+   uint64_t bit = UINT64_C (1) << 63;
+   size_t count = 0;
+   while ((bit & in) == 0 && bit > 0) {
+      bit >>= 1;
+      ++count;
+   }
+   return count;
+}
+
+// count_leading_zeros_u32 returns the number of leading 0 bits of `in`.
+static inline size_t
+mc_count_leading_zeros_u32 (uint32_t in)
+{
+#ifdef __has_builtin
+#if __has_builtin(__builtin_clz)
+   // Pointer-cast to ensure we are speaking the right type
+   unsigned int *p = &in;
+   return (size_t) (in ? __builtin_clz (*p) : 32);
+#endif
+#endif
+   uint32_t bit = UINT32_C (1) << 31;
+   int count = 0;
+   while ((bit & in) == 0 && bit > 0) {
+      bit >>= 1;
+      ++count;
+   }
+   return (size_t) count;
+}
+
+static inline size_t
+mc_count_leading_zeros_u128 (mlib_int128 in)
+{
+   size_t hi = mc_count_leading_zeros_u64 (
+      mlib_int128_to_u64 (mlib_int128_rshift (in, 64)));
+   size_t lo = mc_count_leading_zeros_u64 (mlib_int128_to_u64 (in));
+   return hi + ((hi == 64 ? 1u : 0u) * lo);
+}
+
+typedef struct mc_bitstring {
+   char str[129];
+} mc_bitstring;
+
+// mc_convert_to_bitstring_u64 returns a 64 character string of 1's and 0's
+// representing the bits of `in`
+mc_bitstring
+mc_convert_to_bitstring_u64 (uint64_t in);
+
+// mc_convert_to_bitstring_u32 returns a 32 character string of 1's and 0's
+// representing the bits of `in`.
+mc_bitstring
+mc_convert_to_bitstring_u32 (uint32_t in);
+
+mc_bitstring
+mc_convert_to_bitstring_u128 (mlib_int128 i);
+
+#endif /* MC_RANGE_EDGE_GENERATION_PRIVATE_H */

data/ext/libmongocrypt/libmongocrypt/src/mc-range-edge-generation.c

@@ -0,0 +1,242 @@
+/*
+ * Copyright 2022-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 "mc-range-edge-generation-private.h"
+
+#include "mc-array-private.h"
+#include "mc-check-conversions-private.h"
+#include "mc-range-encoding-private.h"
+#include "mongocrypt-private.h"
+
+struct _mc_edges_t {
+   size_t sparsity;
+   /* edges is an array of `char*` edge strings. */
+   mc_array_t edges;
+};
+
+static mc_edges_t *
+mc_edges_new (const char *leaf, size_t sparsity, mongocrypt_status_t *status)
+{
+   BSON_ASSERT_PARAM (leaf);
+   if (sparsity < 1) {
+      CLIENT_ERR ("sparsity must be 1 or larger");
+      return NULL;
+   }
+   mc_edges_t *edges = bson_malloc0 (sizeof (mc_edges_t));
+   edges->sparsity = sparsity;
+   _mc_array_init (&edges->edges, sizeof (char *));
+
+   char *root = bson_strdup ("root");
+   _mc_array_append_val (&edges->edges, root);
+
+   char *leaf_copy = bson_strdup (leaf);
+   _mc_array_append_val (&edges->edges, leaf_copy);
+
+   const size_t leaf_len = strlen (leaf);
+   // Start loop at 1. The full leaf is unconditionally appended after loop.
+   for (size_t i = 1; i < leaf_len; i++) {
+      if (i % sparsity == 0) {
+         char *edge = bson_malloc (i + 1);
+         bson_strncpy (edge, leaf, i + 1);
+         _mc_array_append_val (&edges->edges, edge);
+      }
+   }
+
+   return edges;
+}
+
+const char *
+mc_edges_get (mc_edges_t *edges, size_t index)
+{
+   BSON_ASSERT_PARAM (edges);
+   if (edges->edges.len == 0 || index > edges->edges.len - 1u) {
+      return NULL;
+   }
+   return _mc_array_index (&edges->edges, char *, index);
+}
+
+size_t
+mc_edges_len (mc_edges_t *edges)
+{
+   BSON_ASSERT_PARAM (edges);
+   return edges->edges.len;
+}
+
+void
+mc_edges_destroy (mc_edges_t *edges)
+{
+   if (NULL == edges) {
+      return;
+   }
+   for (size_t i = 0; i < edges->edges.len; i++) {
+      char *val = _mc_array_index (&edges->edges, char *, i);
+      bson_free (val);
+   }
+   _mc_array_destroy (&edges->edges);
+   bson_free (edges);
+}
+
+mc_bitstring
+mc_convert_to_bitstring_u64 (uint64_t in)
+{
+   mc_bitstring ret = {{0}};
+   char *out = ret.str;
+   uint64_t bit = UINT64_C (1) << 63;
+   while (bit > 0) {
+      if (bit & in) {
+         *out++ = '1';
+      } else {
+         *out++ = '0';
+      }
+      bit >>= 1;
+   }
+   return ret;
+}
+
+mc_bitstring
+mc_convert_to_bitstring_u32 (uint32_t in)
+{
+   mc_bitstring ret = {{0}};
+   char *out = ret.str;
+   uint32_t bit = UINT32_C (1) << 31;
+   while (bit > 0) {
+      if (bit & in) {
+         *out++ = '1';
+      } else {
+         *out++ = '0';
+      }
+      bit >>= 1;
+   }
+   return ret;
+}
+
+mc_bitstring
+mc_convert_to_bitstring_u128 (mlib_int128 i)
+{
+   const uint64_t lo = mlib_int128_to_u64 (i);
+   const uint64_t hi = mlib_int128_to_u64 (mlib_int128_rshift (i, 64));
+   mc_bitstring his = mc_convert_to_bitstring_u64 (hi);
+   mc_bitstring los = mc_convert_to_bitstring_u64 (lo);
+   mc_bitstring ret = {{0}};
+   const size_t off =
+      mlib_strnmcopy (ret.str, sizeof ret.str, his.str, sizeof his.str);
+   mlib_strnmcopy (
+      ret.str + off, (sizeof ret.str) - off, los.str, sizeof los.str);
+   return ret;
+}
+
+mc_edges_t *
+mc_getEdgesInt32 (mc_getEdgesInt32_args_t args, mongocrypt_status_t *status)
+{
+   mc_OSTType_Int32 got;
+   if (!mc_getTypeInfo32 ((mc_getTypeInfo32_args_t){.value = args.value,
+                                                    .min = args.min,
+                                                    .max = args.max},
+                          &got,
+                          status)) {
+      return NULL;
+   }
+
+   // `max` is the domain of values. `max` is used to determine the maximum bit
+   // length. `min` is expected to be zero. The `min` and `max` terms are kept
+   // for consistency with the server implementation.
+   BSON_ASSERT (got.min == 0);
+
+   mc_bitstring valueBin = mc_convert_to_bitstring_u32 (got.value);
+   size_t offset = mc_count_leading_zeros_u32 (got.max);
+   const char *leaf = valueBin.str + offset;
+   mc_edges_t *ret = mc_edges_new (leaf, args.sparsity, status);
+   return ret;
+}
+
+mc_edges_t *
+mc_getEdgesInt64 (mc_getEdgesInt64_args_t args, mongocrypt_status_t *status)
+{
+   mc_OSTType_Int64 got;
+   if (!mc_getTypeInfo64 ((mc_getTypeInfo64_args_t){.value = args.value,
+                                                    .min = args.min,
+                                                    .max = args.max},
+                          &got,
+                          status)) {
+      return NULL;
+   }
+
+   // `max` is the domain of values. `max` is used to determine the maximum bit
+   // length. `min` is expected to be zero. The `min` and `max` terms are kept
+   // for consistency with the server implementation.
+   BSON_ASSERT (got.min == 0);
+
+   mc_bitstring valueBin = mc_convert_to_bitstring_u64 (got.value);
+   size_t offset = mc_count_leading_zeros_u64 (got.max);
+   const char *leaf = valueBin.str + offset;
+   mc_edges_t *ret = mc_edges_new (leaf, args.sparsity, status);
+   return ret;
+}
+
+
+mc_edges_t *
+mc_getEdgesDouble (mc_getEdgesDouble_args_t args, mongocrypt_status_t *status)
+{
+   mc_OSTType_Double got;
+   if (!mc_getTypeInfoDouble (
+          (mc_getTypeInfoDouble_args_t){.value = args.value,
+                                        .min = args.min,
+                                        .max = args.max,
+                                        .precision = args.precision},
+          &got,
+          status)) {
+      return NULL;
+   }
+
+   // `max` is the domain of values. `max` is used to determine the maximum bit
+   // length. `min` is expected to be zero. The `min` and `max` terms are kept
+   // for consistency with the server implementation.
+   BSON_ASSERT (got.min == 0);
+
+   mc_bitstring valueBin = mc_convert_to_bitstring_u64 (got.value);
+   size_t offset = mc_count_leading_zeros_u64 (got.max);
+   const char *leaf = valueBin.str + offset;
+   mc_edges_t *ret = mc_edges_new (leaf, args.sparsity, status);
+   return ret;
+}
+
+#if MONGOCRYPT_HAVE_DECIMAL128_SUPPORT
+mc_edges_t *
+mc_getEdgesDecimal128 (mc_getEdgesDecimal128_args_t args,
+                       mongocrypt_status_t *status)
+{
+   mc_OSTType_Decimal128 got;
+   if (!mc_getTypeInfoDecimal128 (
+          (mc_getTypeInfoDecimal128_args_t){
+             .value = args.value,
+             .min = args.min,
+             .max = args.max,
+             .precision = args.precision,
+          },
+          &got,
+          status)) {
+      return NULL;
+   }
+
+   BSON_ASSERT (mlib_int128_eq (got.min, MLIB_INT128 (0)));
+
+   mc_bitstring bits = mc_convert_to_bitstring_u128 (got.value);
+   size_t offset = mc_count_leading_zeros_u128 (got.max);
+   const char *leaf = bits.str + offset;
+   mc_edges_t *ret = mc_edges_new (leaf, args.sparsity, status);
+   return ret;
+}
+#endif // MONGOCRYPT_HAVE_DECIMAL128_SUPPORT

data/ext/libmongocrypt/libmongocrypt/src/mc-range-encoding-private.h

@@ -0,0 +1,128 @@
+/*
+ * Copyright 2022-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 MC_RANGE_ENCODING_PRIVATE_H
+#define MC_RANGE_ENCODING_PRIVATE_H
+
+#include "mc-optional-private.h"
+#include "mc-dec128.h"
+#include "mongocrypt-status-private.h"
+
+#include <mlib/int128.h>
+
+#include <stdint.h>
+
+/* mc-range-encoding-private.h has functions to encode numeric types for
+ * Queryable Encryption Range queries. It is a translation from server code:
+ * https://github.com/mongodb/mongo/blob/1364f5c5004ac5503837ac5b315c189625f97269/src/mongo/crypto/fle_crypto.h#L1194-L1196
+ * "OST" is an abbreviation taken from server code. It stands for "Outsourced
+ * STate".
+ */
+
+/* mc_OSTType_Int32 describes the encoding of a BSON int32. */
+typedef struct {
+   uint32_t value;
+   uint32_t min;
+   uint32_t max;
+} mc_OSTType_Int32;
+
+typedef struct {
+   int32_t value;
+   mc_optional_int32_t min;
+   mc_optional_int32_t max;
+} mc_getTypeInfo32_args_t;
+
+/* mc_getTypeInfo32 encodes the int32_t `args.value` into an OSTType_Int32
+ * `out`. `args.min` and `args.max` may be unset. Returns false and sets
+ * `status` on error. */
+bool
+mc_getTypeInfo32 (mc_getTypeInfo32_args_t args,
+                  mc_OSTType_Int32 *out,
+                  mongocrypt_status_t *status) MONGOCRYPT_WARN_UNUSED_RESULT;
+
+/* mc_OSTType_Int64 describes the encoding of a BSON int64. */
+typedef struct {
+   uint64_t value;
+   uint64_t min;
+   uint64_t max;
+} mc_OSTType_Int64;
+
+typedef struct {
+   int64_t value;
+   mc_optional_int64_t min;
+   mc_optional_int64_t max;
+} mc_getTypeInfo64_args_t;
+
+/* mc_getTypeInfo64 encodes the int64_t `args.value` into an OSTType_Int64
+ * `out`. `args.min` and `args.max` may be unset. Returns false and sets
+ * `status` on error. */
+bool
+mc_getTypeInfo64 (mc_getTypeInfo64_args_t args,
+                  mc_OSTType_Int64 *out,
+                  mongocrypt_status_t *status) MONGOCRYPT_WARN_UNUSED_RESULT;
+
+/* mc_OSTType_Double describes the encoding of a BSON double. */
+typedef struct {
+   uint64_t value;
+   uint64_t min;
+   uint64_t max;
+} mc_OSTType_Double;
+
+typedef struct {
+   double value;
+   mc_optional_double_t min;
+   mc_optional_double_t max;
+   mc_optional_uint32_t precision;
+} mc_getTypeInfoDouble_args_t;
+
+/* mc_getTypeInfoDouble encodes the double `args.value` into an OSTType_Double
+ * `out`. Returns false and sets `status` on error. */
+bool
+mc_getTypeInfoDouble (mc_getTypeInfoDouble_args_t args,
+                      mc_OSTType_Double *out,
+                      mongocrypt_status_t *status)
+   MONGOCRYPT_WARN_UNUSED_RESULT;
+
+#if MONGOCRYPT_HAVE_DECIMAL128_SUPPORT
+/**
+ * @brief OST-encoding of a Decimal128
+ */
+typedef struct {
+   mlib_int128 value, min, max;
+} mc_OSTType_Decimal128;
+
+typedef struct {
+   mc_dec128 value;
+   mc_optional_dec128_t min, max;
+   mc_optional_uint32_t precision;
+} mc_getTypeInfoDecimal128_args_t;
+
+/**
+ * @brief Obtain the OST encoding of a finite Decimal128 value.
+ *
+ * @param out Output for the result
+ * @param status Output for status on error
+ * @retval true On success
+ * @retval false Otherwise
+ */
+bool
+mc_getTypeInfoDecimal128 (mc_getTypeInfoDecimal128_args_t args,
+                          mc_OSTType_Decimal128 *out,
+                          mongocrypt_status_t *status)
+   MONGOCRYPT_WARN_UNUSED_RESULT;
+#endif // MONGOCRYPT_HAVE_DECIMAL128_SUPPORT
+
+#endif /* MC_RANGE_ENCODING_PRIVATE_H */