libmongocrypt-helper 1.11.0.0.1001 → 1.13.2.0.1001

data/ext/libmongocrypt/libmongocrypt/src/mc-fle2-rfds-private.h

@@ -41,6 +41,11 @@ typedef struct {
     mc_FLE2RangeOperator_t secondOp;
 } mc_FLE2RangeFindDriverSpec_t;
 
+// `mc_FLE2RangeFindDriverSpec_t` inherits extended alignment from libbson. To dynamically allocate, use
+// aligned allocation (e.g. BSON_ALIGNED_ALLOC)
+BSON_STATIC_ASSERT2(alignof_mc_FLE2RangeFindDriverSpec_t,
+                    BSON_ALIGNOF(mc_FLE2RangeFindDriverSpec_t) >= BSON_ALIGNOF(bson_iter_t));
+
 // mc_FLE2RangeFindDriverSpec_parse parses a FLE2RangeFindDriverSpec document.
 bool mc_FLE2RangeFindDriverSpec_parse(mc_FLE2RangeFindDriverSpec_t *spec,
                                       const bson_t *in,
@@ -79,6 +84,11 @@ typedef struct {
     mc_optional_int32_t trimFactor;
 } mc_makeRangeFindPlaceholder_args_t;
 
+// `mc_makeRangeFindPlaceholder_args_t` inherits extended alignment from libbson. To dynamically allocate, use
+// aligned allocation (e.g. BSON_ALIGNED_ALLOC)
+BSON_STATIC_ASSERT2(alignof_mc_makeRangeFindPlaceholder_args_t,
+                    BSON_ALIGNOF(mc_makeRangeFindPlaceholder_args_t) >= BSON_ALIGNOF(bson_iter_t));
+
 // mc_makeRangeFindPlaceholder creates a placeholder to be consumed by
 // libmongocrypt to encrypt a range find query. It is included in the header to
 // be used by tests.

data/ext/libmongocrypt/libmongocrypt/src/mc-fle2-tag-and-encrypted-metadata-block-private.h

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2024-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_FLE2_TAG_AND_ENCRYPTED_METADATA_BLOCK_H
+#define MC_FLE2_TAG_AND_ENCRYPTED_METADATA_BLOCK_H
+
+#include "mc-reader-private.h"
+#include "mc-writer-private.h"
+#include "mongocrypt-private.h"
+
+#define kMetadataLen 96U // encCount(32) + tag(32) + encZeros(32)
+
+typedef struct _mc_FLE2TagAndEncryptedMetadataBlock_t {
+    _mongocrypt_buffer_t encryptedCount;
+    _mongocrypt_buffer_t tag;
+    _mongocrypt_buffer_t encryptedZeros;
+} mc_FLE2TagAndEncryptedMetadataBlock_t;
+
+#define kFieldLen 32U
+
+void mc_FLE2TagAndEncryptedMetadataBlock_init(mc_FLE2TagAndEncryptedMetadataBlock_t *metadata);
+
+void mc_FLE2TagAndEncryptedMetadataBlock_cleanup(mc_FLE2TagAndEncryptedMetadataBlock_t *metadata);
+
+bool mc_FLE2TagAndEncryptedMetadataBlock_parse(mc_FLE2TagAndEncryptedMetadataBlock_t *metadata,
+                                               const _mongocrypt_buffer_t *buf,
+                                               mongocrypt_status_t *status);
+
+bool mc_FLE2TagAndEncryptedMetadataBlock_serialize(const mc_FLE2TagAndEncryptedMetadataBlock_t *metadata,
+                                                   _mongocrypt_buffer_t *buf,
+                                                   mongocrypt_status_t *status);
+
+bool mc_FLE2TagAndEncryptedMetadataBlock_validate(const mc_FLE2TagAndEncryptedMetadataBlock_t *metadata,
+                                                  mongocrypt_status_t *status);
+
+#endif /* MC_FLE2_TAG_AND_ENCRYPTED_METADATA_BLOCK_H */

data/ext/libmongocrypt/libmongocrypt/src/mc-fle2-tag-and-encrypted-metadata-block.c

@@ -0,0 +1,98 @@
+/*
+ * Copyright 2024-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-fle2-tag-and-encrypted-metadata-block-private.h"
+#include "mc-reader-private.h"
+#include "mc-writer-private.h"
+#include "mongocrypt-private.h"
+
+#define CHECK_AND_RETURN(x)                                                                                            \
+    if (!(x)) {                                                                                                        \
+        return false;                                                                                                  \
+    }
+
+void mc_FLE2TagAndEncryptedMetadataBlock_init(mc_FLE2TagAndEncryptedMetadataBlock_t *metadata) {
+    BSON_ASSERT_PARAM(metadata);
+    memset(metadata, 0, sizeof(mc_FLE2TagAndEncryptedMetadataBlock_t));
+}
+
+void mc_FLE2TagAndEncryptedMetadataBlock_cleanup(mc_FLE2TagAndEncryptedMetadataBlock_t *metadata) {
+    BSON_ASSERT_PARAM(metadata);
+
+    _mongocrypt_buffer_cleanup(&metadata->encryptedCount);
+    _mongocrypt_buffer_cleanup(&metadata->tag);
+    _mongocrypt_buffer_cleanup(&metadata->encryptedZeros);
+}
+
+bool mc_FLE2TagAndEncryptedMetadataBlock_parse(mc_FLE2TagAndEncryptedMetadataBlock_t *metadata,
+                                               const _mongocrypt_buffer_t *buf,
+                                               mongocrypt_status_t *status) {
+    BSON_ASSERT_PARAM(metadata);
+    BSON_ASSERT_PARAM(buf);
+
+    if ((buf->data == NULL) || (buf->len == 0)) {
+        CLIENT_ERR("Empty buffer passed to mc_FLE2IndexedEncryptedValueV2_parse");
+        return false;
+    }
+
+    mc_reader_t reader;
+    mc_reader_init_from_buffer(&reader, buf, __FUNCTION__);
+
+    mc_FLE2TagAndEncryptedMetadataBlock_init(metadata);
+
+    CHECK_AND_RETURN(mc_reader_read_buffer(&reader, &metadata->encryptedCount, kFieldLen, status));
+
+    CHECK_AND_RETURN(mc_reader_read_buffer(&reader, &metadata->tag, kFieldLen, status));
+
+    CHECK_AND_RETURN(mc_reader_read_buffer(&reader, &metadata->encryptedZeros, kFieldLen, status));
+
+    return true;
+}
+
+bool mc_FLE2TagAndEncryptedMetadataBlock_serialize(const mc_FLE2TagAndEncryptedMetadataBlock_t *metadata,
+                                                   _mongocrypt_buffer_t *buf,
+                                                   mongocrypt_status_t *status) {
+    BSON_ASSERT_PARAM(metadata);
+    BSON_ASSERT_PARAM(buf);
+
+    _mongocrypt_buffer_resize(buf, kMetadataLen);
+    mc_writer_t writer;
+    mc_writer_init_from_buffer(&writer, buf, __FUNCTION__);
+
+    CHECK_AND_RETURN(mc_writer_write_buffer(&writer, &metadata->encryptedCount, kFieldLen, status));
+
+    CHECK_AND_RETURN(mc_writer_write_buffer(&writer, &metadata->tag, kFieldLen, status));
+
+    CHECK_AND_RETURN(mc_writer_write_buffer(&writer, &metadata->encryptedZeros, kFieldLen, status));
+
+    return true;
+}
+
+#define CHECK(condition, msg)                                                                                          \
+    do {                                                                                                               \
+        if (!(condition)) {                                                                                            \
+            CLIENT_ERR("mc_FLE2TagAndEncryptedMetadataBlock_validate failed: " msg);                                   \
+            return false;                                                                                              \
+        }                                                                                                              \
+    } while (0)
+
+bool mc_FLE2TagAndEncryptedMetadataBlock_validate(const mc_FLE2TagAndEncryptedMetadataBlock_t *metadata,
+                                                  mongocrypt_status_t *status) {
+    CHECK(metadata->encryptedCount.len == kFieldLen, "Length of encrypted count was unexpected");
+    CHECK(metadata->tag.len == kFieldLen, "Length of tag was unexpected");
+    CHECK(metadata->encryptedZeros.len == kFieldLen, "Length of encrypted zeros was unexpected");
+    return true;
+}

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

@@ -19,6 +19,7 @@
 
 #include "mc-array-private.h"
 #include "mc-check-conversions-private.h"
+#include "mc-cmp-private.h"
 #include "mc-range-encoding-private.h"
 #include "mongocrypt-private.h"
 
@@ -47,7 +48,7 @@ static mc_edges_t *mc_edges_new(const char *leaf,
 
     const size_t leaf_len = strlen(leaf);
     const int32_t trimFactor = trimFactorDefault(leaf_len, opt_trimFactor, use_range_v2);
-    if (trimFactor != 0 && bson_cmp_greater_equal_su(trimFactor, leaf_len)) {
+    if (trimFactor != 0 && mc_cmp_greater_equal_su(trimFactor, leaf_len)) {
         // We append a total of leaf_len + 1 (for the root) - trimFactor edges. When this number is equal to 1, we
         // degenerate into equality, which is not desired, so trimFactor must be less than leaf_len.
         CLIENT_ERR("trimFactor must be less than the number of bits (%ld) used to represent an element of the domain, "
@@ -76,7 +77,7 @@ static mc_edges_t *mc_edges_new(const char *leaf,
     _mc_array_append_val(&edges->edges, leaf_copy);
 
     // Start loop at max(trimFactor, 1). The full leaf is unconditionally appended after loop.
-    BSON_ASSERT(bson_in_range_size_t_signed(trimFactor));
+    BSON_ASSERT(mc_in_range_size_t_signed(trimFactor));
     size_t trimFactor_sz = (size_t)trimFactor;
     size_t startLevel = trimFactor > 0 ? trimFactor_sz : 1;
     for (size_t i = startLevel; i < leaf_len; i++) {

data/ext/libmongocrypt/libmongocrypt/src/mc-range-encoding.c

@@ -15,6 +15,7 @@
  */
 
 #include "mc-check-conversions-private.h"
+#include "mc-cmp-private.h"
 #include "mc-range-encoding-private.h"
 #include "mongocrypt-private.h"
 #include "mongocrypt-util-private.h" // mc_isinf
@@ -863,7 +864,7 @@ int32_t trimFactorDefault(size_t maxlen, mc_optional_int32_t trimFactor, bool us
         return 0;
     }
 
-    if (bson_cmp_greater_su(mc_FLERangeTrimFactorDefault, maxlen - 1)) {
+    if (mc_cmp_greater_su(mc_FLERangeTrimFactorDefault, maxlen - 1)) {
         return (int32_t)(maxlen - 1);
     } else {
         return mc_FLERangeTrimFactorDefault;

data/ext/libmongocrypt/libmongocrypt/src/mc-range-mincover-generator.template.h

@@ -124,7 +124,7 @@ static inline DECORATE_NAME(MinCoverGenerator)
     }
     size_t maxlen = (size_t)BITS - DECORATE_NAME(mc_count_leading_zeros)(max);
     int32_t trimFactor = trimFactorDefault(maxlen, opt_trimFactor, use_range_v2);
-    if (trimFactor != 0 && bson_cmp_greater_equal_su(trimFactor, maxlen)) {
+    if (trimFactor != 0 && mc_cmp_greater_equal_su(trimFactor, maxlen)) {
         CLIENT_ERR("Trim factor must be less than the number of bits (%ld) used to represent an element of the domain, "
                    "but got %" PRId32,
                    maxlen,
@@ -169,7 +169,7 @@ static inline bool DECORATE_NAME(MinCoverGenerator_isLevelStored)(DECORATE_NAME(
                                                                   size_t maskedBits) {
     BSON_ASSERT_PARAM(mcg);
     size_t level = mcg->_maxlen - maskedBits;
-    BSON_ASSERT(bson_in_range_size_t_signed(mcg->_trimFactor));
+    BSON_ASSERT(mc_in_range_size_t_signed(mcg->_trimFactor));
     size_t trimFactor_sz = (size_t)mcg->_trimFactor;
     return 0 == maskedBits || (level >= trimFactor_sz && 0 == (level % mcg->_sparsity));
 }

data/ext/libmongocrypt/libmongocrypt/src/mc-range-mincover.c

@@ -19,6 +19,7 @@
 #include "mc-check-conversions-private.h"
 
 #include "mc-array-private.h"
+#include "mc-cmp-private.h"
 #include "mc-range-edge-generation-private.h" // mc_count_leading_zeros_u32
 #include "mc-range-encoding-private.h"        // mc_getTypeInfo32, trimFactorDefault
 #include "mc-range-mincover-private.h"

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

@@ -40,12 +40,17 @@ typedef struct {
     mc_optional_int32_t trimFactor;
 } mc_RangeOpts_t;
 
+// `mc_RangeOpts_t` inherits extended alignment from libbson. To dynamically allocate, use
+// aligned allocation (e.g. BSON_ALIGNED_ALLOC)
+BSON_STATIC_ASSERT2(alignof_mc_RangeOpts_t,
+                    BSON_ALIGNOF(mc_RangeOpts_t) >= BSON_MAX(BSON_ALIGNOF(bson_t), BSON_ALIGNOF(bson_iter_t)));
+
 /* mc_RangeOpts_parse parses a BSON document into mc_RangeOpts_t.
  * The document is expected to have the form:
  * {
  *    "min": BSON value,
  *    "max": BSON value,
- *    "sparsity": Int64,
+ *    "sparsity": Optional<Int64>,
  *    "precision": Optional<Int32>,
  *    "trimFactor": Optional<Int32>,
  * }

data/ext/libmongocrypt/libmongocrypt/src/mc-rangeopts.c

@@ -17,6 +17,7 @@
 #include "mc-rangeopts-private.h"
 
 #include "mc-check-conversions-private.h"
+#include "mc-cmp-private.h"
 #include "mc-range-edge-generation-private.h" // mc_count_leading_zeros_XX
 #include "mc-range-encoding-private.h"        // mc_getTypeInfoXX
 #include "mongocrypt-private.h"
@@ -504,7 +505,7 @@ bool mc_RangeOpts_appendTrimFactor(const mc_RangeOpts_t *ro,
     }
     // if nbits = 0, we want to allow trim factor = 0.
     uint32_t test = nbits ? nbits : 1;
-    if (bson_cmp_greater_equal_su(ro->trimFactor.value, test)) {
+    if (mc_cmp_greater_equal_su(ro->trimFactor.value, test)) {
         CLIENT_ERR_PREFIXED("Trim factor (%d) must be less than the total number of bits (%d) used to represent "
                             "any element in the domain.",
                             ro->trimFactor.value,

data/ext/libmongocrypt/libmongocrypt/src/mc-schema-broker-private.h

@@ -0,0 +1,126 @@
+/*
+ * 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 MC_SCHEMA_BROKER_PRIVATE_H
+#define MC_SCHEMA_BROKER_PRIVATE_H
+
+#include "mc-efc-private.h" // mc_EncryptedFieldConfig_t
+#include "mongocrypt-cache-collinfo-private.h"
+#include "mongocrypt.h"
+#include <bson/bson.h>
+
+// mc_schema_broker_t manages schemas for an auto encryption operation.
+//
+// A schema is either:
+// - a JSON Schema for CSFLE operations, or
+// - an encryptedFields document for QE operations.
+//
+typedef struct mc_schema_broker_t mc_schema_broker_t;
+
+mc_schema_broker_t *mc_schema_broker_new(void);
+
+void mc_schema_broker_destroy(mc_schema_broker_t *sb);
+
+// mc_schema_broker_use_rangev2 enables rangev2 behavior. TODO(MONGOCRYPT-711) remove once rangev1 code is removed.
+void mc_schema_broker_use_rangev2(mc_schema_broker_t *sb);
+
+// mc_schema_broker_request requests a schema for a collection. Ignores duplicates.
+// Returns error if two requests have different databases (not-yet supported).
+bool mc_schema_broker_request(mc_schema_broker_t *sb, const char *db, const char *coll, mongocrypt_status_t *status);
+
+// mc_schema_broker_has_multiple_requests returns true if there are requests for multiple unique collections
+bool mc_schema_broker_has_multiple_requests(const mc_schema_broker_t *sb);
+
+// mc_schema_broker_append_listCollections_filter appends a filter to use with the listCollections command.
+// Example: { "name": { "$in": [ "coll1", "coll2" ] } }
+// The filter matches all not-yet-satisfied collections.
+bool mc_schema_broker_append_listCollections_filter(const mc_schema_broker_t *sb,
+                                                    bson_t *out,
+                                                    mongocrypt_status_t *status);
+
+// mc_schema_broker_satisfy_from_collinfo satisfies a schema request with a result from listCollections.
+// The result is cached.
+bool mc_schema_broker_satisfy_from_collinfo(mc_schema_broker_t *sb,
+                                            const bson_t *collinfo,
+                                            _mongocrypt_cache_t *collinfo_cache,
+                                            mongocrypt_status_t *status);
+
+// mc_schema_broker_satisfy_from_schemaMap tries to satisfy schema requests with a schemaMap.
+bool mc_schema_broker_satisfy_from_schemaMap(mc_schema_broker_t *sb,
+                                             const bson_t *schema_map,
+                                             mongocrypt_status_t *status);
+
+// mc_schema_broker_satisfy_from_encryptedFieldsMap tries to satisfy schema requests with an encryptedFieldsMap.
+bool mc_schema_broker_satisfy_from_encryptedFieldsMap(mc_schema_broker_t *sb,
+                                                      const bson_t *ef_map,
+                                                      mongocrypt_status_t *status);
+
+// mc_schema_broker_satisfy_from_cache tries to satisfy schema requests with the cache of listCollections results.
+bool mc_schema_broker_satisfy_from_cache(mc_schema_broker_t *sb,
+                                         _mongocrypt_cache_t *collinfo_cache,
+                                         mongocrypt_status_t *status);
+
+// mc_schema_broker_satisfy_from_create_or_collMod tries to satisfy a schema request by inspecting the outgoing
+// create/collMod commands.
+bool mc_schema_broker_satisfy_from_create_or_collMod(mc_schema_broker_t *sb,
+                                                     const bson_t *cmd,
+                                                     mongocrypt_status_t *status);
+
+// mc_schema_broker_satisfy_remaining_from_empty_schemas is called when a driver signals all listCollection results
+// have been fed. Assumes remaining collections have no schema. If collinfo_cache is passed, the empty result is cached.
+bool mc_schema_broker_satisfy_remaining_with_empty_schemas(mc_schema_broker_t *sb,
+                                                           _mongocrypt_cache_t *collinfo_cache /* may be NULL */,
+                                                           mongocrypt_status_t *status);
+
+// mc_schema_broker_has_any_qe_schemas returns true if any collection has encryptedFields.
+//
+// Aborts if any unsatisfied schema requests. `mc_schema_broker_need_more_schemas(sb)` must be false.
+//
+bool mc_schema_broker_has_any_qe_schemas(const mc_schema_broker_t *sb);
+
+// mc_schema_broker_need_more_schemas returns true if there are unsatisfied schema requests.
+bool mc_schema_broker_need_more_schemas(const mc_schema_broker_t *sb);
+
+// mc_schema_broker_get_encryptedFields returns encryptedFields for a collection.
+//
+// Returns NULL and sets error if `coll` is not found or has no encryptedFields.
+//
+// Aborts if any unsatisfied schema requests. `mc_schema_broker_need_more_schemas(sb)` must be false.
+//
+const mc_EncryptedFieldConfig_t *
+mc_schema_broker_get_encryptedFields(const mc_schema_broker_t *sb, const char *coll, mongocrypt_status_t *status);
+
+typedef enum {
+    MC_CMD_SCHEMAS_FOR_CRYPT_SHARED, // target the crypt_shared library.
+    MC_CMD_SCHEMAS_FOR_MONGOCRYPTD,  // target mongocryptd process.
+    MC_CMD_SCHEMAS_FOR_SERVER        // target the server (mongod/mongos).
+} mc_cmd_target_t;
+
+// mc_schema_broker_add_schemas_to_cmd adds schema information to a command.
+//
+// Aborts if any unsatisfied schema requests. `mc_schema_broker_need_more_schemas(sb)` must be false.
+//
+// Schemas are added with the fields:
+// - jsonSchema: for CSFLE with one schema.
+// - csfleEncryptionSchemas: for CSFLE with multiple schemas.
+// - encryptionInformation: for QE.
+//
+// Set cmd_target to the intended command destination. This impacts if/how schema information is added.
+bool mc_schema_broker_add_schemas_to_cmd(const mc_schema_broker_t *sb,
+                                         bson_t *cmd /* in and out */,
+                                         mc_cmd_target_t cmd_target,
+                                         mongocrypt_status_t *status);
+#endif // MC_SCHEMA_BROKER_PRIVATE_H