libmongocrypt-helper 1.7.4.0.1001 → 1.8.0.0.1001

data/ext/libmongocrypt/libmongocrypt/test/test-mongocrypt-ciphertext.c

@@ -14,14 +14,13 @@
  * limitations under the License.
  */
 
-#include "mongocrypt-private.h"
 #include "mongocrypt-ciphertext-private.h"
 #include "mongocrypt-crypto-private.h"
 #include "mongocrypt-marking-private.h"
+#include "mongocrypt-private.h"
 
 #include "test-mongocrypt.h"
 
-
 /* From BSON Binary subtype 6 specification:
 struct fle_blob {
  uint8  fle_blob_subtype = (1 or 2);
@@ -30,230 +29,196 @@ struct fle_blob {
  uint8  ciphertext[ciphertext_length];
 }
 */
-static void
-_test_ciphertext_serialization (_mongocrypt_tester_t *tester)
-{
-   _mongocrypt_ciphertext_t original, returned;
-   _mongocrypt_buffer_t serialized;
-   char *expected = "\x01\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C"
-                    "\x0D\x0E\x0F\x02\x00\x01";
-   mongocrypt_status_t *status;
-
-   _mongocrypt_ciphertext_init (&original);
-   _mongocrypt_ciphertext_init (&returned);
-   _mongocrypt_buffer_init (&serialized);
-   status = mongocrypt_status_new ();
-
-   original.blob_subtype = 1;
-   original.original_bson_type = 2;
-   _mongocrypt_tester_fill_buffer (&original.data, 2);
-   _mongocrypt_tester_fill_buffer (&original.key_id, 16);
-
-   BSON_ASSERT (_mongocrypt_serialize_ciphertext (&original, &serialized));
-   BSON_ASSERT (0 == memcmp (expected, serialized.data, serialized.len));
-
-   /* Now parse it back, should get the same ciphertext. */
-   BSON_ASSERT (
-      _mongocrypt_ciphertext_parse_unowned (&serialized, &returned, status));
-   BSON_ASSERT (original.blob_subtype == returned.blob_subtype);
-   BSON_ASSERT (original.original_bson_type == returned.original_bson_type);
-   BSON_ASSERT (0 ==
-                _mongocrypt_buffer_cmp (&original.key_id, &returned.key_id));
-   BSON_ASSERT (0 == _mongocrypt_buffer_cmp (&original.data, &returned.data));
-
-   _mongocrypt_ciphertext_cleanup (&original);
-   _mongocrypt_ciphertext_cleanup (&returned);
-   _mongocrypt_buffer_cleanup (&serialized);
-   mongocrypt_status_destroy (status);
+static void _test_ciphertext_serialization(_mongocrypt_tester_t *tester) {
+    _mongocrypt_ciphertext_t original, returned;
+    _mongocrypt_buffer_t serialized;
+    char *expected = "\x01\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C"
+                     "\x0D\x0E\x0F\x02\x00\x01";
+    mongocrypt_status_t *status;
+
+    _mongocrypt_ciphertext_init(&original);
+    _mongocrypt_ciphertext_init(&returned);
+    _mongocrypt_buffer_init(&serialized);
+    status = mongocrypt_status_new();
+
+    original.blob_subtype = 1;
+    original.original_bson_type = 2;
+    _mongocrypt_tester_fill_buffer(&original.data, 2);
+    _mongocrypt_tester_fill_buffer(&original.key_id, 16);
+
+    BSON_ASSERT(_mongocrypt_serialize_ciphertext(&original, &serialized));
+    BSON_ASSERT(0 == memcmp(expected, serialized.data, serialized.len));
+
+    /* Now parse it back, should get the same ciphertext. */
+    BSON_ASSERT(_mongocrypt_ciphertext_parse_unowned(&serialized, &returned, status));
+    BSON_ASSERT(original.blob_subtype == returned.blob_subtype);
+    BSON_ASSERT(original.original_bson_type == returned.original_bson_type);
+    BSON_ASSERT(0 == _mongocrypt_buffer_cmp(&original.key_id, &returned.key_id));
+    BSON_ASSERT(0 == _mongocrypt_buffer_cmp(&original.data, &returned.data));
+
+    _mongocrypt_ciphertext_cleanup(&original);
+    _mongocrypt_ciphertext_cleanup(&returned);
+    _mongocrypt_buffer_cleanup(&serialized);
+    mongocrypt_status_destroy(status);
 }
 
-
-static void
-_test_malformed_ciphertext (_mongocrypt_tester_t *tester)
-{
-   _mongocrypt_buffer_t serialized;
-   _mongocrypt_ciphertext_t returned;
-   mongocrypt_status_t *status;
-
-   status = mongocrypt_status_new ();
-   /* the minimum size for a ciphertext is 19 bytes. */
-   _mongocrypt_tester_fill_buffer (&serialized, 18);
-
-   BSON_ASSERT (
-      !_mongocrypt_ciphertext_parse_unowned (&serialized, &returned, status));
-   BSON_ASSERT (0 == strcmp (mongocrypt_status_message (status, NULL),
-                             "malformed ciphertext, too small"));
-   _mongocrypt_buffer_cleanup (&serialized);
-
-   _mongocrypt_tester_fill_buffer (&serialized, 19);
-   /* give a valid blob_subtype. */
-   serialized.data[0] = 1;
-   BSON_ASSERT (
-      _mongocrypt_ciphertext_parse_unowned (&serialized, &returned, status));
-
-   /* now an invalid blob_subtype. */
-   serialized.data[0] = 16;
-   BSON_ASSERT (
-      !_mongocrypt_ciphertext_parse_unowned (&serialized, &returned, status));
-   BSON_ASSERT (
-      0 == strcmp (mongocrypt_status_message (status, NULL),
-                   "malformed ciphertext, expected blob subtype of 1 or 2"));
-
-   _mongocrypt_ciphertext_cleanup (&returned);
-   _mongocrypt_buffer_cleanup (&serialized);
-   mongocrypt_status_destroy (status);
+static void _test_malformed_ciphertext(_mongocrypt_tester_t *tester) {
+    _mongocrypt_buffer_t serialized;
+    _mongocrypt_ciphertext_t returned;
+    mongocrypt_status_t *status;
+
+    status = mongocrypt_status_new();
+    /* the minimum size for a ciphertext is 19 bytes. */
+    _mongocrypt_tester_fill_buffer(&serialized, 18);
+
+    BSON_ASSERT(!_mongocrypt_ciphertext_parse_unowned(&serialized, &returned, status));
+    BSON_ASSERT(0 == strcmp(mongocrypt_status_message(status, NULL), "malformed ciphertext, too small"));
+    _mongocrypt_buffer_cleanup(&serialized);
+
+    _mongocrypt_tester_fill_buffer(&serialized, 19);
+    /* give a valid blob_subtype. */
+    serialized.data[0] = 1;
+    BSON_ASSERT(_mongocrypt_ciphertext_parse_unowned(&serialized, &returned, status));
+
+    /* now an invalid blob_subtype. */
+    serialized.data[0] = 16;
+    BSON_ASSERT(!_mongocrypt_ciphertext_parse_unowned(&serialized, &returned, status));
+    BSON_ASSERT(
+        0 == strcmp(mongocrypt_status_message(status, NULL), "malformed ciphertext, expected blob subtype of 1 or 2"));
+
+    _mongocrypt_ciphertext_cleanup(&returned);
+    _mongocrypt_buffer_cleanup(&serialized);
+    mongocrypt_status_destroy(status);
 }
 
-
-void
-_test_ciphertext_algorithm (_mongocrypt_tester_t *tester)
-{
-   mongocrypt_t *crypt;
-   mongocrypt_ctx_t *ctx;
-   mongocrypt_status_t *status;
-   _mongocrypt_key_broker_t *kb;
-   _mongocrypt_buffer_t zeros;
-   _mongocrypt_ciphertext_t type1_valueA, type1_valueA_again, type2_valueA,
-      type1_valueB;
-   _mongocrypt_marking_t marking = {0};
-   bson_iter_t a_iter, b_iter;
-   bson_t *bson;
-   bool res;
-
-   status = mongocrypt_status_new ();
-   _mongocrypt_ciphertext_init (&type1_valueA);
-   _mongocrypt_ciphertext_init (&type1_valueA_again);
-   _mongocrypt_ciphertext_init (&type2_valueA);
-   _mongocrypt_ciphertext_init (&type1_valueB);
-
-   _mongocrypt_buffer_init (&zeros);
-   _mongocrypt_buffer_resize (&zeros, MONGOCRYPT_IV_LEN);
-   memset (zeros.data, 0, MONGOCRYPT_IV_LEN);
-
-   crypt = _mongocrypt_tester_mongocrypt (TESTER_MONGOCRYPT_DEFAULT);
-   /* use a mongocrypt_ctx_t to get a key broker */
-   ctx = mongocrypt_ctx_new (crypt);
-   ASSERT_OK (mongocrypt_ctx_encrypt_init (
-                 ctx, "test", -1, TEST_FILE ("./test/example/cmd.json")),
-              ctx);
-
-   _mongocrypt_buffer_from_binary (&marking.key_id, TEST_BIN (16));
-   marking.key_id.subtype = BSON_SUBTYPE_UUID;
-   kb = &ctx->kb;
-   _mongocrypt_key_broker_add_test_key (kb, &marking.key_id);
-
-   bson = BCON_NEW ("v", "a", "v", "b");
-   bson_iter_init (&a_iter, bson);
-   bson_iter_next (&a_iter);
-   bson_iter_init (&b_iter, bson);
-   bson_iter_next (&b_iter);
-   bson_iter_next (&b_iter);
-
-   /* Marking type = 1, plaintext = a */
-   marking.algorithm = 1;
-   memcpy (&marking.v_iter, &a_iter, sizeof (bson_iter_t));
-   res = _mongocrypt_marking_to_ciphertext (
-      (void *) kb, &marking, &type1_valueA, status);
-   ASSERT_OR_PRINT (res, status);
-
-   /* Marking type = 1, plaintext = a */
-   marking.algorithm = 1;
-   memcpy (&marking.v_iter, &a_iter, sizeof (bson_iter_t));
-   res = _mongocrypt_marking_to_ciphertext (
-      (void *) kb, &marking, &type1_valueA_again, status);
-   ASSERT_OR_PRINT (res, status);
-
-   /* Marking type = 2, plaintext = a */
-   marking.algorithm = 2;
-   memcpy (&marking.v_iter, &a_iter, sizeof (bson_iter_t));
-   res = _mongocrypt_marking_to_ciphertext (
-      (void *) kb, &marking, &type2_valueA, status);
-   ASSERT_OR_PRINT (res, status);
-
-   /* Marking type = 1, plaintext = b */
-   marking.algorithm = 1;
-   memcpy (&marking.v_iter, &b_iter, sizeof (bson_iter_t));
-   res = _mongocrypt_marking_to_ciphertext (
-      (void *) kb, &marking, &type1_valueB, status);
-   ASSERT_OR_PRINT (res, status);
-
-   /* Shorten all buffers to their IV length's */
-   type1_valueA.data.len = MONGOCRYPT_IV_LEN;
-   type1_valueA_again.data.len = MONGOCRYPT_IV_LEN;
-   type2_valueA.data.len = MONGOCRYPT_IV_LEN;
-   type1_valueB.data.len = MONGOCRYPT_IV_LEN;
-
-
-   BSON_ASSERT (0 != _mongocrypt_buffer_cmp (&type1_valueA.data, &zeros));
-   BSON_ASSERT (0 != _mongocrypt_buffer_cmp (&type1_valueA_again.data, &zeros));
-   BSON_ASSERT (0 != _mongocrypt_buffer_cmp (&type2_valueA.data, &zeros));
-   BSON_ASSERT (0 != _mongocrypt_buffer_cmp (&type1_valueB.data, &zeros));
-
-   /* Type 1 IV should be repeatable for same plaintext. */
-   BSON_ASSERT (0 == _mongocrypt_buffer_cmp (&type1_valueA.data,
-                                             &type1_valueA_again.data));
-   /* Type 1 IV should differ from type 2 random IV. */
-   BSON_ASSERT (
-      0 != _mongocrypt_buffer_cmp (&type1_valueA.data, &type2_valueA.data));
-   /* Type 1 IV should differ if plaintext differs. */
-   BSON_ASSERT (
-      0 != _mongocrypt_buffer_cmp (&type1_valueA.data, &type1_valueB.data));
-
-
-   _mongocrypt_ciphertext_cleanup (&type1_valueA);
-   _mongocrypt_ciphertext_cleanup (&type1_valueA_again);
-   _mongocrypt_ciphertext_cleanup (&type2_valueA);
-   _mongocrypt_ciphertext_cleanup (&type1_valueB);
-   _mongocrypt_buffer_cleanup (&zeros);
-   _mongocrypt_marking_cleanup (&marking);
-   mongocrypt_ctx_destroy (ctx);
-   mongocrypt_destroy (crypt);
-   bson_destroy (bson);
-   mongocrypt_status_destroy (status);
+void _test_ciphertext_algorithm(_mongocrypt_tester_t *tester) {
+    mongocrypt_t *crypt;
+    mongocrypt_ctx_t *ctx;
+    mongocrypt_status_t *status;
+    _mongocrypt_key_broker_t *kb;
+    _mongocrypt_buffer_t zeros;
+    _mongocrypt_ciphertext_t type1_valueA, type1_valueA_again, type2_valueA, type1_valueB;
+    _mongocrypt_marking_t marking = {0};
+    bson_iter_t a_iter, b_iter;
+    bson_t *bson;
+    bool res;
+
+    status = mongocrypt_status_new();
+    _mongocrypt_ciphertext_init(&type1_valueA);
+    _mongocrypt_ciphertext_init(&type1_valueA_again);
+    _mongocrypt_ciphertext_init(&type2_valueA);
+    _mongocrypt_ciphertext_init(&type1_valueB);
+
+    _mongocrypt_buffer_init(&zeros);
+    _mongocrypt_buffer_resize(&zeros, MONGOCRYPT_IV_LEN);
+    memset(zeros.data, 0, MONGOCRYPT_IV_LEN);
+
+    crypt = _mongocrypt_tester_mongocrypt(TESTER_MONGOCRYPT_DEFAULT);
+    /* use a mongocrypt_ctx_t to get a key broker */
+    ctx = mongocrypt_ctx_new(crypt);
+    ASSERT_OK(mongocrypt_ctx_encrypt_init(ctx, "test", -1, TEST_FILE("./test/example/cmd.json")), ctx);
+
+    _mongocrypt_buffer_from_binary(&marking.key_id, TEST_BIN(16));
+    marking.key_id.subtype = BSON_SUBTYPE_UUID;
+    kb = &ctx->kb;
+    _mongocrypt_key_broker_add_test_key(kb, &marking.key_id);
+
+    bson = BCON_NEW("v", "a", "v", "b");
+    bson_iter_init(&a_iter, bson);
+    bson_iter_next(&a_iter);
+    bson_iter_init(&b_iter, bson);
+    bson_iter_next(&b_iter);
+    bson_iter_next(&b_iter);
+
+    /* Marking type = 1, plaintext = a */
+    marking.algorithm = 1;
+    memcpy(&marking.v_iter, &a_iter, sizeof(bson_iter_t));
+    res = _mongocrypt_marking_to_ciphertext((void *)kb, &marking, &type1_valueA, status);
+    ASSERT_OR_PRINT(res, status);
+
+    /* Marking type = 1, plaintext = a */
+    marking.algorithm = 1;
+    memcpy(&marking.v_iter, &a_iter, sizeof(bson_iter_t));
+    res = _mongocrypt_marking_to_ciphertext((void *)kb, &marking, &type1_valueA_again, status);
+    ASSERT_OR_PRINT(res, status);
+
+    /* Marking type = 2, plaintext = a */
+    marking.algorithm = 2;
+    memcpy(&marking.v_iter, &a_iter, sizeof(bson_iter_t));
+    res = _mongocrypt_marking_to_ciphertext((void *)kb, &marking, &type2_valueA, status);
+    ASSERT_OR_PRINT(res, status);
+
+    /* Marking type = 1, plaintext = b */
+    marking.algorithm = 1;
+    memcpy(&marking.v_iter, &b_iter, sizeof(bson_iter_t));
+    res = _mongocrypt_marking_to_ciphertext((void *)kb, &marking, &type1_valueB, status);
+    ASSERT_OR_PRINT(res, status);
+
+    /* Shorten all buffers to their IV length's */
+    type1_valueA.data.len = MONGOCRYPT_IV_LEN;
+    type1_valueA_again.data.len = MONGOCRYPT_IV_LEN;
+    type2_valueA.data.len = MONGOCRYPT_IV_LEN;
+    type1_valueB.data.len = MONGOCRYPT_IV_LEN;
+
+    BSON_ASSERT(0 != _mongocrypt_buffer_cmp(&type1_valueA.data, &zeros));
+    BSON_ASSERT(0 != _mongocrypt_buffer_cmp(&type1_valueA_again.data, &zeros));
+    BSON_ASSERT(0 != _mongocrypt_buffer_cmp(&type2_valueA.data, &zeros));
+    BSON_ASSERT(0 != _mongocrypt_buffer_cmp(&type1_valueB.data, &zeros));
+
+    /* Type 1 IV should be repeatable for same plaintext. */
+    BSON_ASSERT(0 == _mongocrypt_buffer_cmp(&type1_valueA.data, &type1_valueA_again.data));
+    /* Type 1 IV should differ from type 2 random IV. */
+    BSON_ASSERT(0 != _mongocrypt_buffer_cmp(&type1_valueA.data, &type2_valueA.data));
+    /* Type 1 IV should differ if plaintext differs. */
+    BSON_ASSERT(0 != _mongocrypt_buffer_cmp(&type1_valueA.data, &type1_valueB.data));
+
+    _mongocrypt_ciphertext_cleanup(&type1_valueA);
+    _mongocrypt_ciphertext_cleanup(&type1_valueA_again);
+    _mongocrypt_ciphertext_cleanup(&type2_valueA);
+    _mongocrypt_ciphertext_cleanup(&type1_valueB);
+    _mongocrypt_buffer_cleanup(&zeros);
+    _mongocrypt_marking_cleanup(&marking);
+    mongocrypt_ctx_destroy(ctx);
+    mongocrypt_destroy(crypt);
+    bson_destroy(bson);
+    mongocrypt_status_destroy(status);
 }
 
-
-void
-_test_ciphertext_serialize_associated_data (_mongocrypt_tester_t *tester)
-{
-   _mongocrypt_ciphertext_t ciphertext;
-   _mongocrypt_buffer_t serialized;
-   /* Expected associated data is:
-    * One byte for blob subtype for deterministic encryption:
-    * \x01
-    * Followed by 16 byte UUID, a repeating 123 pattern:
-    * \x01\x02\x03\x01\x02\x03\x01\x02\x03\x01\x02\x03\x01\x02\x03\x01
-    * Followed by the BSON type for UTF8
-    * \x02
-    */
-   char *expected = "\x01\x01\x02\x03\x01\x02\x03\x01\x02\x03\x01\x02\x03\x01"
-                    "\x02\x03\x01\x02";
-
-   _mongocrypt_ciphertext_init (&ciphertext);
-   _mongocrypt_buffer_init (&serialized);
-
-   /* Create a UUID */
-   _mongocrypt_buffer_from_binary (&ciphertext.key_id, TEST_BIN (16));
-   ciphertext.key_id.subtype = BSON_SUBTYPE_UUID;
-
-   ciphertext.original_bson_type = BSON_TYPE_UTF8;
-   ciphertext.blob_subtype = MC_SUBTYPE_FLE1DeterministicEncryptedValue;
-
-   BSON_ASSERT (_mongocrypt_ciphertext_serialize_associated_data (&ciphertext,
-                                                                  &serialized));
-   BSON_ASSERT (serialized.len == 18);
-   BSON_ASSERT (0 == memcmp (serialized.data, expected, strlen (expected)));
-
-   _mongocrypt_ciphertext_cleanup (&ciphertext);
-   _mongocrypt_buffer_cleanup (&serialized);
+void _test_ciphertext_serialize_associated_data(_mongocrypt_tester_t *tester) {
+    _mongocrypt_ciphertext_t ciphertext;
+    _mongocrypt_buffer_t serialized;
+    /* Expected associated data is:
+     * One byte for blob subtype for deterministic encryption:
+     * \x01
+     * Followed by 16 byte UUID, a repeating 123 pattern:
+     * \x01\x02\x03\x01\x02\x03\x01\x02\x03\x01\x02\x03\x01\x02\x03\x01
+     * Followed by the BSON type for UTF8
+     * \x02
+     */
+    char *expected = "\x01\x01\x02\x03\x01\x02\x03\x01\x02\x03\x01\x02\x03\x01"
+                     "\x02\x03\x01\x02";
+
+    _mongocrypt_ciphertext_init(&ciphertext);
+    _mongocrypt_buffer_init(&serialized);
+
+    /* Create a UUID */
+    _mongocrypt_buffer_from_binary(&ciphertext.key_id, TEST_BIN(16));
+    ciphertext.key_id.subtype = BSON_SUBTYPE_UUID;
+
+    ciphertext.original_bson_type = BSON_TYPE_UTF8;
+    ciphertext.blob_subtype = MC_SUBTYPE_FLE1DeterministicEncryptedValue;
+
+    BSON_ASSERT(_mongocrypt_ciphertext_serialize_associated_data(&ciphertext, &serialized));
+    BSON_ASSERT(serialized.len == 18);
+    BSON_ASSERT(0 == memcmp(serialized.data, expected, strlen(expected)));
+
+    _mongocrypt_ciphertext_cleanup(&ciphertext);
+    _mongocrypt_buffer_cleanup(&serialized);
 }
 
-
-void
-_mongocrypt_tester_install_ciphertext (_mongocrypt_tester_t *tester)
-{
-   INSTALL_TEST (_test_malformed_ciphertext);
-   INSTALL_TEST (_test_ciphertext_serialization);
-   INSTALL_TEST (_test_ciphertext_algorithm);
-   INSTALL_TEST (_test_ciphertext_serialize_associated_data);
+void _mongocrypt_tester_install_ciphertext(_mongocrypt_tester_t *tester) {
+    INSTALL_TEST(_test_malformed_ciphertext);
+    INSTALL_TEST(_test_ciphertext_serialization);
+    INSTALL_TEST(_test_ciphertext_algorithm);
+    INSTALL_TEST(_test_ciphertext_serialize_associated_data);
 }