libmongocrypt-helper 1.7.0.0.1001 → 1.7.4.0.1000

data/ext/libmongocrypt/libmongocrypt/bindings/java/mongocrypt/src/test/java/com/mongodb/crypt/capi/MongoCryptTest.java

@@ -0,0 +1,345 @@
+/*
+ * Copyright 2019-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.
+ *
+ */
+
+package com.mongodb.crypt.capi;
+
+import com.mongodb.crypt.capi.MongoCryptContext.State;
+import org.bson.BsonBinary;
+import org.bson.BsonBinarySubType;
+import org.bson.BsonDocument;
+import org.bson.BsonString;
+import org.bson.RawBsonDocument;
+import org.junit.jupiter.api.Test;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.net.URISyntaxException;
+import java.net.URL;
+import java.nio.ByteBuffer;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.util.Arrays;
+import java.util.Base64;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertIterableEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+
+
+@SuppressWarnings("SameParameterValue")
+public class MongoCryptTest {
+    @Test
+    public void testEncrypt() throws URISyntaxException, IOException {
+        MongoCrypt mongoCrypt = createMongoCrypt();
+        assertNotNull(mongoCrypt);
+
+        MongoCryptContext encryptor = mongoCrypt.createEncryptionContext("test", getResourceAsDocument("command.json"));
+
+        assertEquals(State.NEED_MONGO_COLLINFO, encryptor.getState());
+
+        BsonDocument listCollectionsFilter = encryptor.getMongoOperation();
+        assertEquals(getResourceAsDocument("list-collections-filter.json"), listCollectionsFilter);
+
+        encryptor.addMongoOperationResult(getResourceAsDocument("collection-info.json"));
+        encryptor.completeMongoOperation();
+        assertEquals(State.NEED_MONGO_MARKINGS, encryptor.getState());
+
+        BsonDocument jsonSchema = encryptor.getMongoOperation();
+        assertEquals(getResourceAsDocument("mongocryptd-command.json"), jsonSchema);
+
+        encryptor.addMongoOperationResult(getResourceAsDocument("mongocryptd-reply.json"));
+        encryptor.completeMongoOperation();
+        assertEquals(State.NEED_MONGO_KEYS, encryptor.getState());
+
+        testKeyDecryptor(encryptor);
+
+        assertEquals(State.READY, encryptor.getState());
+
+        RawBsonDocument encryptedDocument = encryptor.finish();
+        assertEquals(State.DONE, encryptor.getState());
+        assertEquals(getResourceAsDocument("encrypted-command.json"), encryptedDocument);
+
+        encryptor.close();
+
+        mongoCrypt.close();
+    }
+
+
+    @Test
+    public void testDecrypt() throws IOException, URISyntaxException {
+        MongoCrypt mongoCrypt = createMongoCrypt();
+        assertNotNull(mongoCrypt);
+
+        MongoCryptContext decryptor = mongoCrypt.createDecryptionContext(getResourceAsDocument("encrypted-command-reply.json"));
+
+        assertEquals(State.NEED_MONGO_KEYS, decryptor.getState());
+
+        testKeyDecryptor(decryptor);
+
+        assertEquals(State.READY, decryptor.getState());
+
+        RawBsonDocument decryptedDocument = decryptor.finish();
+        assertEquals(State.DONE, decryptor.getState());
+        assertEquals(getResourceAsDocument("command-reply.json"), decryptedDocument);
+
+        decryptor.close();
+
+        mongoCrypt.close();
+    }
+
+    @Test
+    public void testEmptyAwsCredentials() throws URISyntaxException, IOException {
+        MongoCrypt mongoCrypt = MongoCrypts.create(MongoCryptOptions
+                .builder()
+                .kmsProviderOptions(new BsonDocument("aws", new BsonDocument()))
+                .needsKmsCredentialsStateEnabled(true)
+                .build());
+
+        MongoCryptContext decryptor = mongoCrypt.createDecryptionContext(getResourceAsDocument("encrypted-command-reply.json"));
+
+        assertEquals(State.NEED_KMS_CREDENTIALS, decryptor.getState());
+
+        BsonDocument awsCredentials = new BsonDocument();
+        awsCredentials.put("accessKeyId", new BsonString("example"));
+        awsCredentials.put("secretAccessKey", new BsonString("example"));
+
+        decryptor.provideKmsProviderCredentials(new BsonDocument("aws", awsCredentials));
+
+        assertEquals(State.NEED_MONGO_KEYS, decryptor.getState());
+
+        mongoCrypt.close();
+    }
+
+    @Test
+    public void testMultipleCloseCalls() {
+        MongoCrypt mongoCrypt = createMongoCrypt();
+        assertNotNull(mongoCrypt);
+
+        mongoCrypt.close();
+        mongoCrypt.close();
+    }
+
+    @Test
+    public void testDataKeyCreation() {
+        MongoCrypt mongoCrypt = createMongoCrypt();
+        assertNotNull(mongoCrypt);
+
+        List<String> keyAltNames = Arrays.asList("first", "second");
+        MongoCryptContext dataKeyContext = mongoCrypt.createDataKeyContext("local",
+                MongoDataKeyOptions.builder().masterKey(new BsonDocument())
+                        .keyAltNames(keyAltNames)
+                        .build());
+        assertEquals(State.READY, dataKeyContext.getState());
+
+        RawBsonDocument dataKeyDocument = dataKeyContext.finish();
+        assertEquals(State.DONE, dataKeyContext.getState());
+        assertNotNull(dataKeyDocument);
+
+        List<String> actualKeyAltNames = dataKeyDocument.getArray("keyAltNames").stream()
+                .map(bsonValue -> bsonValue.asString().getValue())
+                .sorted()
+                .collect(Collectors.toList());
+        assertIterableEquals(keyAltNames, actualKeyAltNames);
+        dataKeyContext.close();
+        mongoCrypt.close();
+    }
+
+    @Test
+    public void testExplicitEncryptionDecryption() {
+        MongoCrypt mongoCrypt = createMongoCrypt();
+        assertNotNull(mongoCrypt);
+
+        BsonDocument documentToEncrypt = new BsonDocument("v", new BsonString("hello"));
+        MongoExplicitEncryptOptions options = MongoExplicitEncryptOptions.builder()
+                .keyId(new BsonBinary(BsonBinarySubType.UUID_STANDARD, Base64.getDecoder().decode("YWFhYWFhYWFhYWFhYWFhYQ==")))
+                .algorithm("AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic")
+                .build();
+        MongoCryptContext encryptor = mongoCrypt.createExplicitEncryptionContext(documentToEncrypt, options);
+        assertEquals(State.NEED_MONGO_KEYS, encryptor.getState());
+
+        testKeyDecryptor(encryptor);
+
+        assertEquals(State.READY, encryptor.getState());
+
+        RawBsonDocument encryptedDocument = encryptor.finish();
+        assertEquals(State.DONE, encryptor.getState());
+        assertEquals(getResourceAsDocument("encrypted-value.json"), encryptedDocument);
+
+        MongoCryptContext decryptor = mongoCrypt.createExplicitDecryptionContext(encryptedDocument);
+
+        assertEquals(State.READY, decryptor.getState());
+
+        RawBsonDocument decryptedDocument = decryptor.finish();
+        assertEquals(State.DONE, decryptor.getState());
+        assertEquals(documentToEncrypt, decryptedDocument);
+
+        encryptor.close();
+
+        mongoCrypt.close();
+    }
+
+    @Test
+    public void testExplicitExpressionEncryption() {
+        MongoCrypt mongoCrypt = createMongoCrypt();
+        assertNotNull(mongoCrypt);
+
+        BsonDocument valueToEncrypt = getResourceAsDocument("fle2-find-range-explicit/int32/value-to-encrypt.json");
+        BsonDocument rangeOptions = getResourceAsDocument("fle2-find-range-explicit/int32/rangeopts.json");
+        BsonDocument expectedEncryptedPayload = getResourceAsDocument("fle2-find-range-explicit/int32/encrypted-payload.json");
+
+        MongoExplicitEncryptOptions options = MongoExplicitEncryptOptions.builder()
+                .keyId(new BsonBinary(BsonBinarySubType.UUID_STANDARD, Base64.getDecoder().decode("q83vqxI0mHYSNBI0VniQEg==")))
+                .algorithm("RangePreview")
+                .queryType("rangePreview")
+                .contentionFactor(4L)
+                .rangeOptions(rangeOptions)
+                .build();
+        MongoCryptContext encryptor = mongoCrypt.createEncryptExpressionContext(valueToEncrypt, options);
+        assertEquals(State.NEED_MONGO_KEYS, encryptor.getState());
+
+        testKeyDecryptor(encryptor, "fle2-find-range-explicit/int32/key-filter.json", "keys/ABCDEFAB123498761234123456789012-local-document.json");
+
+        assertEquals(State.READY, encryptor.getState());
+
+        RawBsonDocument actualEncryptedPayload = encryptor.finish();
+        assertEquals(State.DONE, encryptor.getState());
+        assertEquals(expectedEncryptedPayload, actualEncryptedPayload);
+
+        encryptor.close();
+        mongoCrypt.close();
+    }
+
+    @Test
+    public void testExplicitEncryptionDecryptionKeyAltName() throws IOException, URISyntaxException {
+        MongoCrypt mongoCrypt = createMongoCrypt();
+        assertNotNull(mongoCrypt);
+
+        BsonDocument documentToEncrypt = new BsonDocument("v", new BsonString("hello"));
+        MongoExplicitEncryptOptions options = MongoExplicitEncryptOptions.builder()
+                .keyAltName("altKeyName")
+                .algorithm("AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic")
+                .build();
+        MongoCryptContext encryptor = mongoCrypt.createExplicitEncryptionContext(documentToEncrypt, options);
+
+        assertEquals(State.NEED_MONGO_KEYS, encryptor.getState());
+        testKeyDecryptor(encryptor, "key-filter-keyAltName.json", "key-document.json");
+
+        assertEquals(State.READY, encryptor.getState());
+
+        RawBsonDocument encryptedDocument = encryptor.finish();
+        assertEquals(State.DONE, encryptor.getState());
+        assertEquals(getResourceAsDocument("encrypted-value.json"), encryptedDocument);
+
+        MongoCryptContext decryptor = mongoCrypt.createExplicitDecryptionContext(encryptedDocument);
+
+        assertEquals(State.READY, decryptor.getState());
+
+        RawBsonDocument decryptedDocument = decryptor.finish();
+        assertEquals(State.DONE, decryptor.getState());
+        assertEquals(documentToEncrypt, decryptedDocument);
+
+        encryptor.close();
+
+        mongoCrypt.close();
+    }
+
+    private void testKeyDecryptor(final MongoCryptContext context) {
+        testKeyDecryptor(context, "key-filter.json", "key-document.json");
+    }
+
+    private void testKeyDecryptor(final MongoCryptContext context, final String keyFilterPath, final String keyDocumentPath) {
+        BsonDocument keyFilter = context.getMongoOperation();
+        assertEquals(getResourceAsDocument(keyFilterPath), keyFilter);
+        context.addMongoOperationResult(getResourceAsDocument(keyDocumentPath));
+        context.completeMongoOperation();
+        if (context.getState() == State.READY) {
+            return;
+        }
+
+        assertEquals(State.NEED_KMS, context.getState());
+
+        MongoKeyDecryptor keyDecryptor = context.nextKeyDecryptor();
+        assertEquals("aws", keyDecryptor.getKmsProvider());
+        assertEquals("kms.us-east-1.amazonaws.com:443", keyDecryptor.getHostName());
+
+        ByteBuffer keyDecryptorMessage = keyDecryptor.getMessage();
+        assertEquals(790, keyDecryptorMessage.remaining());
+
+        int bytesNeeded = keyDecryptor.bytesNeeded();
+        assertEquals(1024, bytesNeeded);
+
+        keyDecryptor.feed(getHttpResourceAsByteBuffer("kms-reply.txt"));
+        bytesNeeded = keyDecryptor.bytesNeeded();
+        assertEquals(0, bytesNeeded);
+
+        assertNull(context.nextKeyDecryptor());
+
+        context.completeKeyDecryptors();
+    }
+
+    private MongoCrypt createMongoCrypt() {
+        return MongoCrypts.create(MongoCryptOptions
+                .builder()
+                .awsKmsProviderOptions(MongoAwsKmsProviderOptions.builder()
+                        .accessKeyId("example")
+                        .secretAccessKey("example")
+                        .build())
+                .localKmsProviderOptions(MongoLocalKmsProviderOptions.builder()
+                        .localMasterKey(ByteBuffer.wrap(new byte[96]))
+                        .build())
+                .build());
+    }
+
+    private static BsonDocument getResourceAsDocument(final String fileName)  {
+        return BsonDocument.parse(getFileAsString(fileName, System.getProperty("line.separator")));
+    }
+
+    private static ByteBuffer getHttpResourceAsByteBuffer(final String fileName) {
+        return ByteBuffer.wrap(getFileAsString(fileName, "\r\n").getBytes(StandardCharsets.UTF_8));
+    }
+
+    private static String getFileAsString(final String fileName, String lineSeparator)  {
+        try {
+            URL resource = MongoCryptTest.class.getResource("/" + fileName);
+            if (resource == null) {
+                throw new RuntimeException("Could not find file " + fileName);
+            }
+            File file = new File(resource.toURI());
+            StringBuilder stringBuilder = new StringBuilder();
+            String line;
+            try (BufferedReader reader = new BufferedReader(
+                    new InputStreamReader(Files.newInputStream(file.toPath()), StandardCharsets.UTF_8))) {
+                boolean first = true;
+                while ((line = reader.readLine()) != null) {
+                    if (!first) {
+                        stringBuilder.append(lineSeparator);
+                    }
+                    first = false;
+                    stringBuilder.append(line);
+                }
+            }
+            return stringBuilder.toString();
+        } catch (Throwable t) {
+            throw new RuntimeException("Could not parse file " + fileName, t);
+        }
+    }
+}

data/ext/libmongocrypt/libmongocrypt/bindings/java/mongocrypt/src/test/resources/collection-info.json

@@ -0,0 +1,37 @@
+{
+    "type": "collection",
+    "name": "test",
+    "idIndex": {
+        "ns": "test.test",
+        "name": "_id_",
+        "key": {
+            "_id": {
+                "$numberInt": "1"
+            }
+        },
+        "v": {
+            "$numberInt": "2"
+        }
+    },
+    "options": {
+        "validator": {
+            "$jsonSchema": {
+                "properties": {
+                    "ssn": {
+                        "encrypt": {
+                            "keyId": {
+                                "$binary": {
+                                    "base64": "YWFhYWFhYWFhYWFhYWFhYQ==",
+                                    "subType": "04"
+                                }
+                            },
+                            "type": "string",
+                            "algorithm": "AEAD_AES_CBC_HMAC_SHA512-Deterministic"
+                        }
+                    }
+                },
+                "bsonType": "object"
+            }
+        }
+    }
+}

data/ext/libmongocrypt/libmongocrypt/bindings/java/mongocrypt/src/test/resources/command-reply.json

@@ -0,0 +1,13 @@
+{
+  "cursor": {
+    "firstBatch": [
+      {
+        "_id": 1,
+        "ssn": "457-55-5462"
+      }
+    ],
+    "id": 0,
+    "ns": "test.test"
+  },
+  "ok": 1
+}

data/ext/libmongocrypt/libmongocrypt/bindings/java/mongocrypt/src/test/resources/command.json

@@ -0,0 +1,6 @@
+{
+    "find": "test",
+    "filter": {
+        "ssn": "457-55-5462"
+    }
+}

data/ext/libmongocrypt/libmongocrypt/bindings/java/mongocrypt/src/test/resources/encrypted-command-reply.json

@@ -0,0 +1,16 @@
+{
+  "cursor" : {
+    "firstBatch" : [
+      {
+        "_id": 1,
+        "ssn": {
+          "$binary": "AWFhYWFhYWFhYWFhYWFhYWECRTOW9yZzNDn5dGwuqsrJQNLtgMEKaujhs9aRWRp+7Yo3JK8N8jC8P0Xjll6C1CwLsE/iP5wjOMhVv1KMMyOCSCrHorXRsb2IKPtzl2lKTqQ=",
+          "$type": "06"
+        }
+      }
+    ],
+    "id" : 0,
+    "ns" : "test.test"
+  },
+  "ok" : 1
+}

data/ext/libmongocrypt/libmongocrypt/bindings/java/mongocrypt/src/test/resources/encrypted-command.json

@@ -0,0 +1,11 @@
+{
+  "filter": {
+    "ssn": {
+      "$binary": {
+        "base64": "AWFhYWFhYWFhYWFhYWFhYWECRTOW9yZzNDn5dGwuqsrJQNLtgMEKaujhs9aRWRp+7Yo3JK8N8jC8P0Xjll6C1CwLsE/iP5wjOMhVv1KMMyOCSCrHorXRsb2IKPtzl2lKTqQ=",
+        "subType": "06"
+      }
+    }
+  },
+  "find": "test"
+}

data/ext/libmongocrypt/libmongocrypt/bindings/java/mongocrypt/src/test/resources/encrypted-value.json

@@ -0,0 +1,6 @@
+{
+  "v": {
+    "$binary": "AWFhYWFhYWFhYWFhYWFhYWECW+zDjR/69eS6VtuMD5+O2lZw6JyiWOw3avI7mnUkdpKzPfvy8F/nlZrgZa2cGmQsb0TmLZuk5trldosnGKD91w==",
+    "$type": "06"
+  }
+}

data/ext/libmongocrypt/libmongocrypt/bindings/java/mongocrypt/src/test/resources/fle2-find-range-explicit/int32/encrypted-payload.json

@@ -0,0 +1,26 @@
+{
+    "v": {
+        "$and": [
+            {
+                "age": {
+                    "$gte": {
+                        "$binary": {
+                            "base64": "CgUCAAADcGF5bG9hZADBAQAABGcAhQEAAAMwAH0AAAAFZAAgAAAAAInd0noBhIiJMv8QTjcfgRqnnVhxRJRRACLfvgT+CTR/BXMAIAAAAADm0EjqF/T4EmR6Dw6NaPLrL0OuzS4AFvm90czFluAAygVjACAAAAAA0d8XgDtErXhD2Il47RZ6es9tJjjenynp6roL00NDzzwAAzEAfQAAAAVkACAAAAAA7lkNtT6RLw91aJ07K/blwlFs5wi9pQjqUXDcaCTxe98FcwAgAAAAAPwySffuLQihmF70Ot93KtaUMNU8KpmA+niyPRcvarNMBWMAIAAAAADH7BDBCS/7LwB7NYkxPNDb5QXXROFnh2+7z8JFwX7wnQADMgB9AAAABWQAIAAAAACcMWVTbZC4ox5VdjWeYKLgf4oBjpPlbTTAkucm9JPK0wVzACAAAAAA3tIww4ZTytkxFsUKyJbc3zwQ2w7DhkOqaNvX9g8pi3gFYwAgAAAAAOK5ETACEX4i+2e0dDtUeGozbxKNlqmkRK5IEZCrv7M5AAAFZQAgAAAAAL7iv5ju6p02+CadotQZUkgqtSIYD2HaywGsizUpIBYMEmNtAAQAAAAAAAAAABBwYXlsb2FkSWQAAAAAABBmaXJzdE9wZXJhdG9yAAIAAAAQc2Vjb25kT3BlcmF0b3IABAAAAAA=",
+                            "subType": "6"
+                        }
+                    }
+                }
+            },
+            {
+                "age": {
+                    "$lte": {
+                        "$binary": {
+                            "base64": "CjsAAAAQcGF5bG9hZElkAAAAAAAQZmlyc3RPcGVyYXRvcgACAAAAEHNlY29uZE9wZXJhdG9yAAQAAAAA",
+                            "subType": "6"
+                        }
+                    }
+                }
+            }
+        ]
+    }
+}

data/ext/libmongocrypt/libmongocrypt/bindings/java/mongocrypt/src/test/resources/fle2-find-range-explicit/int32/key-filter.json

@@ -0,0 +1,19 @@
+{
+  "$or": [
+    {
+      "_id": {
+        "$in": [
+          {
+            "$binary": "q83vqxI0mHYSNBI0VniQEg==",
+            "$type": "04"
+          }
+        ]
+      }
+    },
+    {
+      "keyAltNames": {
+        "$in": []
+      }
+    }
+  ]
+}

data/ext/libmongocrypt/libmongocrypt/bindings/java/mongocrypt/src/test/resources/fle2-find-range-explicit/int32/rangeopts.json

@@ -0,0 +1,11 @@
+{
+    "min": {
+        "$numberInt": "0"
+    },
+    "max": {
+        "$numberInt": "200"
+    },
+    "sparsity": {
+        "$numberLong": "1"
+    }
+}

data/ext/libmongocrypt/libmongocrypt/bindings/java/mongocrypt/src/test/resources/fle2-find-range-explicit/int32/value-to-encrypt.json

@@ -0,0 +1,20 @@
+{
+    "v": {
+        "$and": [
+            {
+                "age": {
+                    "$gte": {
+                        "$numberInt": "23"
+                    }
+                }
+            },
+            {
+                "age": {
+                    "$lte": {
+                        "$numberInt": "35"
+                    }
+                }
+            }
+        ]
+    }
+}

data/ext/libmongocrypt/libmongocrypt/bindings/java/mongocrypt/src/test/resources/json-schema.json

@@ -0,0 +1,15 @@
+{
+  "properties": {
+    "ssn": {
+      "encrypt": {
+        "keyId": {
+          "$binary": "YWFhYWFhYWFhYWFhYWFhYQ==",
+          "$type": "04"
+        },
+        "type": "string",
+        "algorithm": "AEAD_AES_CBC_HMAC_SHA512-Deterministic"
+      }
+    }
+  },
+  "bsonType": "object"
+}

data/ext/libmongocrypt/libmongocrypt/bindings/java/mongocrypt/src/test/resources/key-document.json

@@ -0,0 +1,36 @@
+{
+    "status": {
+        "$numberInt": "1"
+    },
+    "_id": {
+        "$binary": {
+            "base64": "YWFhYWFhYWFhYWFhYWFhYQ==",
+            "subType": "04"
+        }
+    },
+    "masterKey": {
+        "region": "us-east-1",
+        "key": "arn:aws:kms:us-east-1:579766882180:key/89fcc2c4-08b0-4bd9-9f25-e30687b580d0",
+        "provider": "aws"
+    },
+    "updateDate": {
+        "$date": {
+            "$numberLong": "1557827033449"
+        }
+    },
+    "keyMaterial": {
+        "$binary": {
+            "base64": "AQICAHhQNmWG2CzOm1dq3kWLM+iDUZhEqnhJwH9wZVpuZ94A8gEqnsxXlR51T5EbEVezUqqKAAAAwjCBvwYJKoZIhvcNAQcGoIGxMIGuAgEAMIGoBgkqhkiG9w0BBwEwHgYJYIZIAWUDBAEuMBEEDHa4jo6yp0Z18KgbUgIBEIB74sKxWtV8/YHje5lv5THTl0HIbhSwM6EqRlmBiFFatmEWaeMk4tO4xBX65eq670I5TWPSLMzpp8ncGHMmvHqRajNBnmFtbYxN3E3/WjxmdbOOe+OXpnGJPcGsftc7cB2shRfA4lICPnE26+oVNXT6p0Lo20nY5XC7jyCO",
+            "subType": "00"
+        }
+    },
+    "creationDate": {
+        "$date": {
+            "$numberLong": "1557827033449"
+        }
+    },
+    "keyAltNames": [
+        "altKeyName",
+        "another_altname"
+    ]
+}

data/ext/libmongocrypt/libmongocrypt/bindings/java/mongocrypt/src/test/resources/key-filter-keyAltName.json

@@ -0,0 +1,14 @@
+{
+  "$or": [
+    {
+      "_id": {
+        "$in": []
+      }
+    },
+    {
+      "keyAltNames": {
+        "$in": ["altKeyName"]
+      }
+    }
+  ]
+}

data/ext/libmongocrypt/libmongocrypt/bindings/java/mongocrypt/src/test/resources/key-filter.json

@@ -0,0 +1,19 @@
+{
+  "$or": [
+    {
+      "_id": {
+        "$in": [
+          {
+            "$binary": "YWFhYWFhYWFhYWFhYWFhYQ==",
+            "$type": "04"
+          }
+        ]
+      }
+    },
+    {
+      "keyAltNames": {
+        "$in": []
+      }
+    }
+  ]
+}

data/ext/libmongocrypt/libmongocrypt/bindings/java/mongocrypt/src/test/resources/keys/ABCDEFAB123498761234123456789012-local-document.json

@@ -0,0 +1,30 @@
+{
+    "_id": {
+        "$binary": {
+            "base64": "q83vqxI0mHYSNBI0VniQEg==",
+            "subType": "04"
+        }
+    },
+    "keyMaterial": {
+        "$binary": {
+            "base64": "27OBvUqHAuYFy60nwCdvq2xmZ4kFzVySphXzBGq+HEot13comCoydEfnltBzLTuXLbV9cnREFJIO5f0jMqrlkxIuvAV8yO84p5VJTEa8j/xSNe7iA594rx7UeKT0fOt4VqM47fht8h+8PZYc5JVezvEMvwk115IBCwENxDjLtT0g+y8Hf+aTUEGtxrYToH8zf1/Y7S16mHiIc4jK3/vxHw==",
+            "subType": "00"
+        }
+    },
+    "creationDate": {
+        "$date": {
+            "$numberLong": "1648915408923"
+        }
+    },
+    "updateDate": {
+        "$date": {
+            "$numberLong": "1648915408923"
+        }
+    },
+    "status": {
+        "$numberInt": "0"
+    },
+    "masterKey": {
+        "provider": "local"
+    }
+}

data/ext/libmongocrypt/libmongocrypt/bindings/java/mongocrypt/src/test/resources/kms-reply.txt

@@ -0,0 +1,6 @@
+HTTP/1.1 200 OK
+x-amzn-RequestId: deeb35e5-4ecb-4bf1-9af5-84a54ff0af0e
+Content-Type: application/x-amz-json-1.1
+Content-Length: 233
+
+{"KeyId": "arn:aws:kms:us-east-1:579766882180:key/89fcc2c4-08b0-4bd9-9f25-e30687b580d0", "Plaintext": "TqhXy3tKckECjy4/ZNykMWG8amBF46isVPzeOgeusKrwheBmYaU8TMG5AHR/NeUDKukqo8hBGgogiQOVpLPkqBQHD8YkLsNbDmHoGOill5QAHnniF/Lz405bGucB5TfR"}

data/ext/libmongocrypt/libmongocrypt/bindings/java/mongocrypt/src/test/resources/list-collections-filter.json

@@ -0,0 +1,3 @@
+{
+  "name": "test"
+}