libmongocrypt-helper 1.8.0.0.1001 → 1.11.0.0.1001

data/ext/libmongocrypt/libmongocrypt/bindings/cs/MongoDB.Libmongocrypt/LibraryLoader.cs

@@ -28,6 +28,7 @@ namespace MongoDB.Libmongocrypt
     internal class LibraryLoader
     {
         private ISharedLibraryLoader _loader;
+        private static readonly string __libmongocryptLibPath = Environment.GetEnvironmentVariable("LIBMONGOCRYPT_PATH");
 
         public LibraryLoader()
         {
@@ -54,40 +55,13 @@ namespace MongoDB.Libmongocrypt
             switch (OperatingSystemHelper.CurrentOperatingSystem)
             {
                 case OperatingSystemPlatform.MacOS:
-                    {
-                        string[] suffixPaths = new[]
-                        {
-                            "../../runtimes/osx/native/",
-                            "runtimes/osx/native/",
-                            string.Empty
-                        };
-                        string path = FindLibrary(candidatePaths, suffixPaths, "libmongocrypt.dylib");
-                        _loader = new DarwinLibraryLoader(path);
-                    }
+                    _loader = new DarwinLibraryLoader(candidatePaths);
                     break;
                 case OperatingSystemPlatform.Linux:
-                    {
-                        string[] suffixPaths = new[]
-                        {
-                            "../../runtimes/linux/native/",
-                            "runtimes/linux/native/",
-                            string.Empty
-                        };
-                        string path = FindLibrary(candidatePaths, suffixPaths, "libmongocrypt.so");
-                        _loader = new LinuxLibrary(path);
-                    }
+                    _loader = new LinuxLibrary(candidatePaths);
                     break;
                 case OperatingSystemPlatform.Windows:
-                    {
-                        string[] suffixPaths = new[]
-                        {
-                            @"..\..\runtimes\win\native\",
-                            @".\runtimes\win\native\",
-                            string.Empty
-                        };
-                        string path = FindLibrary(candidatePaths, suffixPaths, "mongocrypt.dll");
-                        _loader = new WindowsLibrary(path);
-                    }
+                    _loader = new WindowsLibrary(candidatePaths);
                     break;
                 default:
                     // should not be reached. If we're here, then there is a bug in OperatingSystemHelper
@@ -95,7 +69,7 @@ namespace MongoDB.Libmongocrypt
             }
         }
 
-        private string FindLibrary(IList<string> basePaths, string[] suffixPaths, string library)
+        private static string FindLibrary(IList<string> basePaths, string[] suffixPaths, string library)
         {
             var candidates = new List<string>();
             foreach (var basePath in basePaths)
@@ -150,9 +124,17 @@ namespace MongoDB.Libmongocrypt
             public const int RTLD_GLOBAL = 0x8;
             public const int RTLD_NOW = 0x2;
 
+            private static readonly string[] __suffixPaths = 
+            {
+                "../../runtimes/osx/native/",
+                "runtimes/osx/native/",
+                string.Empty
+            };
+
             private readonly IntPtr _handle;
-            public DarwinLibraryLoader(string path)
+            public DarwinLibraryLoader(List<string> candidatePaths)
             {
+                var path = __libmongocryptLibPath ?? FindLibrary(candidatePaths, __suffixPaths, "libmongocrypt.dylib");
                 _handle = dlopen(path, RTLD_GLOBAL | RTLD_NOW);
                 if (_handle == IntPtr.Zero)
                 {
@@ -186,11 +168,37 @@ namespace MongoDB.Libmongocrypt
             // #define RTLD_GLOBAL     0x100
             public const int RTLD_GLOBAL = 0x100;
             public const int RTLD_NOW = 0x2;
+            private static readonly bool _use_libdl1;
+
+            static LinuxLibrary()
+            {
+                try
+                {
+                    Libdl1.dlerror();
+                    _use_libdl1 = true;
+                }
+                catch
+                {
+                    _use_libdl1 = false;
+                }
+            }
+            
+            private static readonly string[] __suffixPaths = 
+            {
+                "../../runtimes/linux/native/",
+                "runtimes/linux/native/",
+                string.Empty
+            };
 
             private readonly IntPtr _handle;
-            public LinuxLibrary(string path)
+            public LinuxLibrary(List<string> candidatePaths)
             {
-                _handle = dlopen(path, RTLD_GLOBAL | RTLD_NOW);
+                var path = __libmongocryptLibPath ?? FindLibrary(candidatePaths, __suffixPaths, "libmongocrypt.so");
+                
+                _handle = _use_libdl1
+                    ? Libdl1.dlopen(path, RTLD_GLOBAL | RTLD_NOW)
+                    : Libdl2.dlopen(path, RTLD_GLOBAL | RTLD_NOW);
+                
                 if (_handle == IntPtr.Zero)
                 {
                     throw new FileNotFoundException(path);
@@ -199,16 +207,8 @@ namespace MongoDB.Libmongocrypt
 
             public IntPtr GetFunction(string name)
             {
-                return dlsym(_handle, name);
+                return _use_libdl1 ? Libdl1.dlsym(_handle, name) : Libdl2.dlsym(_handle, name);
             }
-
-#pragma warning disable IDE1006 // Naming Styles
-            [DllImport("libdl")]
-            public static extern IntPtr dlopen(string filename, int flags);
-
-            [DllImport("libdl", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
-            public static extern IntPtr dlsym(IntPtr handle, string symbol);
-#pragma warning restore IDE1006 // Naming Styles
         }
 
         /// <summary>
@@ -216,9 +216,17 @@ namespace MongoDB.Libmongocrypt
         /// </summary>
         private class WindowsLibrary : ISharedLibraryLoader
         {
+            private static readonly string[] __suffixPaths = 
+            {
+                @"..\..\runtimes\win\native\",
+                @".\runtimes\win\native\",
+                string.Empty
+            };
+            
             private readonly IntPtr _handle;
-            public WindowsLibrary(string path)
+            public WindowsLibrary(List<string> candidatePaths)
             {
+                var path = __libmongocryptLibPath ?? FindLibrary(candidatePaths, __suffixPaths, "mongocrypt.dll");
                 _handle = LoadLibrary(path);
                 if (_handle == IntPtr.Zero)
                 {
@@ -248,5 +256,34 @@ namespace MongoDB.Libmongocrypt
             [DllImport("kernel32", CharSet = CharSet.Ansi, ExactSpelling = true, SetLastError = true)]
             public static extern IntPtr GetProcAddress(IntPtr hModule, string procName);
         }
+        
+        private static class Libdl1
+        {
+            private const string LibName = "libdl";
+            
+#pragma warning disable IDE1006 // Naming Styles
+            [DllImport(LibName)]
+            public static extern IntPtr dlopen(string filename, int flags);
+
+            [DllImport(LibName, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
+            public static extern IntPtr dlsym(IntPtr handle, string symbol);
+            
+            [DllImport(LibName)]
+            public static extern string dlerror();
+#pragma warning restore IDE1006 // Naming Styles
+        }
+        
+        private static class Libdl2
+        {
+            private const string LibName = "libdl.so.2";
+            
+#pragma warning disable IDE1006 // Naming Styles
+            [DllImport(LibName)]
+            public static extern IntPtr dlopen(string filename, int flags);
+
+            [DllImport(LibName, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
+            public static extern IntPtr dlsym(IntPtr handle, string symbol);
+#pragma warning restore IDE1006 // Naming Styles
+        }
     }
 }

data/ext/libmongocrypt/libmongocrypt/bindings/cs/MongoDB.Libmongocrypt/MongoDB.Libmongocrypt.csproj

@@ -24,11 +24,12 @@
     <PackageTags>mongodb;mongo;nosql</PackageTags>
     <PackageLanguage>en-US</PackageLanguage>
     <IncludeSymbols>true</IncludeSymbols>
+    <SignAssembly>true</SignAssembly>
+    <AssemblyOriginatorKeyFile>..\MongoDB.Driver.snk</AssemblyOriginatorKeyFile>
   </PropertyGroup>
 
   <PropertyGroup>
     <LibMongoCryptBinaries>../../../cmake-build/$(Configuration)</LibMongoCryptBinaries>
-    <LibMongoCryptBinaries Condition="'$(Configuration)'=='Release' And '$(OS)' == 'Windows_NT'">../../../cmake-build/RelWithDebInfo/</LibMongoCryptBinaries>
   </PropertyGroup>
 
   <ItemGroup>

data/ext/libmongocrypt/libmongocrypt/bindings/cs/MongoDB.Libmongocrypt.Test/MongoDB.Libmongocrypt.Test.csproj

@@ -6,6 +6,8 @@
 
     <Platforms>AnyCPU</Platforms>
     <IsPackable>false</IsPackable>
+    <SignAssembly>true</SignAssembly>
+    <AssemblyOriginatorKeyFile>..\MongoDB.Driver.snk</AssemblyOriginatorKeyFile>
   </PropertyGroup>
 
   <ItemGroup>

data/ext/libmongocrypt/libmongocrypt/bindings/cs/MongoDB.Libmongocrypt.Test32/MongoDB.Libmongocrypt.Test32.csproj

@@ -4,6 +4,8 @@
         <TargetFrameworks>net472;netcoreapp2.1;netcoreapp3.0</TargetFrameworks>
         <TargetFrameworks Condition="'$(OS)' != 'Windows_NT'">netcoreapp2.1;netcoreapp3.0</TargetFrameworks>
         <IsPackable>false</IsPackable>
+        <SignAssembly>true</SignAssembly>
+        <AssemblyOriginatorKeyFile>..\MongoDB.Driver.snk</AssemblyOriginatorKeyFile>
     </PropertyGroup>
 
     <ItemGroup>

data/ext/libmongocrypt/libmongocrypt/bindings/cs/README.md

@@ -54,6 +54,9 @@ If you see `Windows Error: 126` during tests, like the example below, it means t
 2. cd <build>/bindings/cs
 3. dotnet build cs.build
 ```
+*Note*: You can use the ```LIBMONGOCRYPT_PATH``` environment variable to load a locally installed
+libmongocrypt build. You should specify the absolute path to the libmongocrypt library itself, not just the containing folder. For example on Linux:
+```$ export LIBMONGOCRYPT_PATH='/path/to/libmongocrypt.so'```.
 
 # Testing
 Do not modify xunit.runner.json

data/ext/libmongocrypt/libmongocrypt/bindings/cs/Scripts/build.cake

@@ -1,7 +1,7 @@
-#addin nuget:?package=Cake.FileHelpers&version=3.3.0
-#addin nuget:?package=Cake.Git&version=0.22.0
-#addin nuget:?package=Cake.Incubator&version=5.1.0
-#tool dotnet:?package=GitVersion.Tool&version=5.3.7
+#addin nuget:?package=Cake.FileHelpers&version=5.0.0
+#addin nuget:?package=Cake.Git&version=2.0.0
+#addin nuget:?package=Cake.Incubator&version=7.0.0
+#tool dotnet:?package=GitVersion.Tool&version=5.10.3
 
 using System;
 using System.Linq;
@@ -14,15 +14,17 @@ var gitVersion = GitVersion();
 var buildDirectory = MakeAbsolute(Directory(GetSettingValue("buildDirectory", "c:\\build")));
 var libmongocryptAllDirectory=buildDirectory.Combine("libmongocrypt-all");
 var downloadedMongocryptDirectory=buildDirectory.Combine("downloadedMongocryptDirectory");
-var localReleaseVersion = "local-0.0.0";
+var localReleaseVersion = "0.0.0-local";
 var releaseVersion = GetSettingValue("releaseVersion", localReleaseVersion);
-var fork = GetSettingValue("fork", "https://github.com/mongodb/libmongocrypt.git");
+var fork = GetSettingValue("fork", "git@github.com:mongodb/libmongocrypt.git");
 var branch = GetSettingValue("branch", "master");
-// 1.8.0-alpha0
-var libmongocryptAllUrl = GetSettingValue("url", "https://mciuploads.s3.amazonaws.com/libmongocrypt/all/1.8.0-alpha0/libmongocrypt-all.tar.gz");
+
+// 1.10.0 - latest libmongocrypt release
+var libmongocryptAllUrl = GetSettingValue("url", "https://mciuploads.s3.amazonaws.com/libmongocrypt/all/1.10.0/libmongocrypt-all.tar.gz");
+
 var csharpBindingsGitTagName = $"csharp-v{releaseVersion}";
 var csharpBindingsDirectory = buildDirectory.Combine(csharpBindingsGitTagName);
-var libmongocryptRelWithDebInfoDirectory = csharpBindingsDirectory.Combine("cmake-build").Combine("RelWithDebInfo");
+var libmongocryptRelWithDebInfoDirectory = csharpBindingsDirectory.Combine("cmake-build").Combine($"{configuration}");
 var libmongocryptCsDirectory = csharpBindingsDirectory.Combine("bindings").Combine("cs");
 var libmongocryptSolutionDirectory = libmongocryptCsDirectory.Combine("MongoDB.Libmongocrypt");
 var libmongocryptSolutionFile = libmongocryptSolutionDirectory.CombineWithFilePath("MongoDB.Libmongocrypt.csproj");
@@ -57,16 +59,9 @@ Task("Prepare")
         UncompressToTheCurrentDirectory(nativeLibrariesArchive);
 
         Information("Cloning the libmongocrypt repo..");
-        GitClone(
-            fork, 
-            csharpBindingsDirectory, 
-            new GitCloneSettings
-            {
-                BranchName = branch,
-                Checkout = true,
-                IsBare = false,
-                RecurseSubmodules = true
-            });
+        EnsureDirectoryExists(csharpBindingsDirectory);
+        Git(csharpBindingsDirectory, $"clone {fork} -b {branch} .");
+        Information("Done git clone..");
 
         EnsureDirectoryExists(libmongocryptRelWithDebInfoDirectory);
         EnsureDirectoryExists(downloadedMongocryptDirectory);
@@ -77,7 +72,7 @@ Task("Prepare")
             libmongocryptAllDirectory.Combine("ubuntu1804-64").Combine("nocrypto").Combine("lib").CombineWithFilePath("libmongocrypt.so"),
             downloadedMongocryptDirectory.CombineWithFilePath("libmongocrypt.so"));
         CopyFile(
-            libmongocryptAllDirectory.Combine("macos").Combine("nocrypto").Combine("lib").CombineWithFilePath("libmongocrypt.dylib"),
+            libmongocryptAllDirectory.Combine("macos").Combine("lib").CombineWithFilePath("libmongocrypt.dylib"),
             downloadedMongocryptDirectory.CombineWithFilePath("libmongocrypt.dylib"));
         CopyDirectory(downloadedMongocryptDirectory, libmongocryptRelWithDebInfoDirectory);
     });
@@ -99,7 +94,7 @@ Task("Tests")
     (monikerInfo) =>
     {
         Information($"Test running {monikerInfo.Moniker}..");
-        var settings = new DotNetCoreTestSettings
+        var settings = new DotNetTestSettings
         {
             Configuration = configuration,
             Framework = monikerInfo.Moniker,
@@ -107,7 +102,7 @@ Task("Tests")
         };
         var projectFullPath = libmongocryptTestsSolutionDirectory.CombineWithFilePath("MongoDB.Libmongocrypt.Test.csproj").FullPath;
         Information(projectFullPath);
-        DotNetCoreTest(
+        DotNetTest(
             projectFullPath,
             settings
         );
@@ -120,7 +115,7 @@ Task("CreatePackage")
     {
         var projectFullPath = libmongocryptSolutionFile.FullPath;
         Information($"Project path: {projectFullPath}. ReleaseVersion: {releaseVersion}");
-        var settings = new DotNetCorePackSettings
+        var settings = new DotNetPackSettings
         {
             Configuration = configuration,
             OutputDirectory = artifactsDirectory,
@@ -129,7 +124,7 @@ Task("CreatePackage")
                { "Version", releaseVersion },
             }
         };
-        DotNetCorePack(
+        DotNetPack(
             projectFullPath,
             settings);
     });
@@ -142,9 +137,9 @@ Task("NugetPush")
         var nugetApi = GetSettingValue("NugetApiKey", null);
         var packageFilePath = artifactsDirectory.CombineWithFilePath($"{libmongocryptSolutionFile.GetFilenameWithoutExtension().ToString()}.{releaseVersion}.nupkg");
         Information(packageFilePath);
-        NuGetPush(
+        DotNetNuGetPush(
             packageFilePath,
-            new NuGetPushSettings 
+            new DotNetNuGetPushSettings 
             {
                 ApiKey = nugetApi,
                 Source = "https://api.nuget.org/v3/index.json"

data/ext/libmongocrypt/libmongocrypt/bindings/cs/Scripts/build.config

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+CAKE_VERSION=2.2.0
+DOTNET_VERSION=6.0.400

data/ext/libmongocrypt/libmongocrypt/bindings/java/mongocrypt/benchmarks/build.gradle.kts

@@ -0,0 +1,28 @@
+/*
+ * Copyright 2023-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.
+ *
+ */
+
+plugins {
+    id("application")
+}
+
+application {
+    mainClass.set("com.mongodb.crypt.benchmark.BenchmarkRunner")
+}
+
+dependencies {
+    implementation(project(":")) // Reference to the parent project
+}

data/ext/libmongocrypt/libmongocrypt/bindings/java/mongocrypt/benchmarks/src/main/java/com/mongodb/crypt/benchmark/BenchmarkRunner.java

@@ -0,0 +1,217 @@
+/*
+ * Copyright 2023-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.benchmark;
+
+import com.mongodb.crypt.capi.*;
+import org.bson.*;
+
+import java.io.*;
+import java.net.URL;
+import java.nio.ByteBuffer;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.time.ZoneOffset;
+import java.time.ZonedDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.*;
+import java.util.concurrent.*;
+
+public class BenchmarkRunner {
+    static final int NUM_FIELDS = 1500;
+    static final int NUM_WARMUP_SECS = 2;
+    static final int NUM_SECS = 10;
+    static final byte[] LOCAL_MASTER_KEY = new byte[]{
+            -99, -108, 75, 13, -109, -48, -59, 68, -91, 114, -3, 50, 27, -108, 48, -112, 35, 53,
+            115, 124, -16, -10, -62, -12, -38, 35, 86, -25, -113, 4, -52, -6, -34, 117, -76, 81,
+            -121, -13, -117, -105, -41, 75, 68, 59, -84, 57, -94, -58, 77, -111, 0, 62, -47, -6, 74,
+            48, -63, -46, -58, 94, -5, -84, 65, -14, 72, 19, 60, -101, 80, -4, -89, 36, 122, 46, 2,
+            99, -93, -58, 22, 37, 81, 80, 120, 62, 15, -40, 110, -124, -90, -20, -115, 45, 36, 71,
+            -27, -81
+    };
+
+    private static String getFileAsString(final String fileName) {
+        try {
+            URL resource = BenchmarkRunner.class.getResource("/" + fileName);
+            if (resource == null) {
+                throw new RuntimeException("Could not find file " + fileName);
+            }
+            return new String(Files.readAllBytes(Paths.get(resource.toURI())));
+        } catch (Throwable t) {
+            throw new RuntimeException("Could not parse file " + fileName, t);
+        }
+    }
+
+    private static BsonDocument getResourceAsDocument(final String fileName) {
+        return BsonDocument.parse(getFileAsString(fileName));
+    }
+
+    private static MongoCrypt createMongoCrypt() {
+        return MongoCrypts.create(MongoCryptOptions
+                .builder()
+                .localKmsProviderOptions(MongoLocalKmsProviderOptions.builder()
+                        .localMasterKey(ByteBuffer.wrap(LOCAL_MASTER_KEY))
+                        .build())
+                .build());
+    }
+
+    // DecryptTask decrypts a document repeatedly for a specified number of seconds and records ops/sec.
+    private static class DecryptTask implements Runnable {
+        public DecryptTask (MongoCrypt mongoCrypt, BsonDocument toDecrypt, int numSecs, CountDownLatch doneSignal) {
+            this.mongoCrypt = mongoCrypt;
+            this.toDecrypt = toDecrypt;
+            this.opsPerSecs = new ArrayList<Long>(numSecs);
+            this.numSecs = numSecs;
+            this.doneSignal = doneSignal;
+        }
+        public void run() {
+            for (int i = 0; i < numSecs; i++) {
+                long opsPerSec = 0;
+                long start = System.nanoTime();
+                // Run for one second.
+                while (System.nanoTime() - start < 1_000_000_000) {
+                    try (MongoCryptContext ctx = mongoCrypt.createDecryptionContext(toDecrypt)) {
+                        assert ctx.getState() == MongoCryptContext.State.READY;
+                        ctx.finish();
+                        opsPerSec++;
+                    }
+                }
+                opsPerSecs.add(opsPerSec);
+            }
+            doneSignal.countDown();
+        }
+        public long getMedianOpsPerSecs () {
+            if (opsPerSecs.size() == 0) {
+                throw new IllegalStateException("opsPerSecs is empty. Was `run` called?");
+            }
+            Collections.sort(opsPerSecs);
+            return opsPerSecs.get(numSecs / 2);
+        }
+        private MongoCrypt mongoCrypt;
+        private BsonDocument toDecrypt;
+        private ArrayList<Long> opsPerSecs;
+        private int numSecs;
+        private CountDownLatch doneSignal;
+    }
+    public static void main(String[] args) throws IOException, InterruptedException, ExecutionException {
+        System.out.printf("BenchmarkRunner is using libmongocrypt version=%s, NUM_WARMUP_SECS=%d, NUM_SECS=%d%n", CAPI.mongocrypt_version(null).toString(), NUM_WARMUP_SECS, NUM_SECS);
+        // `keyDocument` is a Data Encryption Key (DEK) encrypted with the Key Encryption Key (KEK) `LOCAL_MASTER_KEY`.
+        BsonDocument keyDocument = getResourceAsDocument("keyDocument.json");
+        try (MongoCrypt mongoCrypt = createMongoCrypt()) {
+            // `encrypted` will contain encrypted fields.
+            BsonDocument encrypted = new BsonDocument();
+            {
+                for (int i = 0; i < NUM_FIELDS; i++) {
+                    MongoExplicitEncryptOptions options = MongoExplicitEncryptOptions.builder()
+                            .keyId(new BsonBinary(BsonBinarySubType.UUID_STANDARD, Base64.getDecoder().decode("YWFhYWFhYWFhYWFhYWFhYQ==")))
+                            .algorithm("AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic")
+                            .build();
+                    BsonDocument toEncrypt = new BsonDocument("v", new BsonString(String.format("value %04d", i)));
+                    try (MongoCryptContext ctx = mongoCrypt.createExplicitEncryptionContext(toEncrypt, options)) {
+                        // If mongocrypt_t has not yet cached the DEK, supply it.
+                        if (MongoCryptContext.State.NEED_MONGO_KEYS == ctx.getState()) {
+                            ctx.addMongoOperationResult(keyDocument);
+                            ctx.completeMongoOperation();
+                        }
+                        assert ctx.getState() == MongoCryptContext.State.READY;
+                        RawBsonDocument result = ctx.finish();
+                        BsonValue encryptedValue = result.get("v");
+                        String key = String.format("key%04d", i);
+                        encrypted.append(key, encryptedValue);
+                    }
+                }
+            }
+
+            // Warm up benchmark and discard the result.
+            DecryptTask warmup = new DecryptTask(mongoCrypt, encrypted, NUM_WARMUP_SECS, new CountDownLatch(1));
+            warmup.run();
+
+            // Decrypt `encrypted` and measure ops/sec.
+            // Check with varying thread counts to measure impact of a shared pool of Cipher instances.
+            int[] threadCounts = {1,2,8,64};
+            ArrayList<Long> totalMedianOpsPerSecs = new ArrayList<Long>(threadCounts.length);
+            ArrayList<String> createdAts = new ArrayList<String>(threadCounts.length);
+            ArrayList<String> completedAts = new ArrayList<String>(threadCounts.length);
+
+            for (int threadCount : threadCounts) {
+                ExecutorService executorService = Executors.newFixedThreadPool(threadCount);
+                CountDownLatch doneSignal = new CountDownLatch(threadCount);
+                ArrayList<DecryptTask> decryptTasks = new ArrayList<DecryptTask>(threadCount);
+                createdAts.add(ZonedDateTime.now(ZoneOffset.UTC).format(DateTimeFormatter.ISO_INSTANT));
+
+                for (int i = 0; i < threadCount; i++) {
+                    DecryptTask decryptTask = new DecryptTask(mongoCrypt, encrypted, NUM_SECS, doneSignal);
+                    decryptTasks.add(decryptTask);
+                    executorService.submit(decryptTask);
+                }
+
+                // Await completion of all tasks. Tasks are expected to complete shortly after NUM_SECS. Time out `await` if time exceeds 2 * NUM_SECS.
+                boolean ok = doneSignal.await(NUM_SECS * 2, TimeUnit.SECONDS);
+                assert ok;
+                completedAts.add(ZonedDateTime.now(ZoneOffset.UTC).format(DateTimeFormatter.ISO_INSTANT));
+                // Sum the median ops/secs of all tasks to get total throughput.
+                long totalMedianOpsPerSec = 0;
+                for (DecryptTask decryptTask : decryptTasks) {
+                    totalMedianOpsPerSec += decryptTask.getMedianOpsPerSecs();
+                }
+                System.out.printf("threadCount=%d. Decrypting 1500 fields median ops/sec : %d%n", threadCount, totalMedianOpsPerSec);
+                totalMedianOpsPerSecs.add(totalMedianOpsPerSec);
+                executorService.shutdown();
+                ok = executorService.awaitTermination(NUM_SECS * 2, TimeUnit.SECONDS);
+                assert ok;
+            }
+
+            // Print the results in JSON that can be accepted by the `perf.send` command.
+            // See https://docs.devprod.prod.corp.mongodb.com/evergreen/Project-Configuration/Project-Commands#perfsend for the expected `perf.send` input.
+            ArrayList<BsonDocument> resultsArray = new ArrayList<BsonDocument>(threadCounts.length);
+            for (int i = 0; i < threadCounts.length; i++) {
+                int threadCount = threadCounts[i];
+                long totalMedianOpsPerSec = totalMedianOpsPerSecs.get(i);
+                String createdAt = createdAts.get(i);
+                String completedAt = completedAts.get(i);
+
+                resultsArray.add(new BsonDocument()
+                    .append("info", new BsonDocument()
+                            .append("test_name", new BsonString("java_decrypt_1500"))
+                            .append("args", new BsonDocument()
+                                .append("threadCount", new BsonInt32(threadCount))))
+                    .append("created_at", new BsonString(createdAt))
+                    .append("completed_at", new BsonString(completedAt))
+                    .append("artifacts", new BsonArray())
+                    .append("metrics", new BsonArray(Arrays.asList(
+                            new BsonDocument()
+                                    .append("name", new BsonString("medianOpsPerSec"))
+                                    .append("type", new BsonString("THROUGHPUT"))
+                                    .append("value", new BsonInt64(totalMedianOpsPerSec))
+                    )))
+                    .append("sub_tests", new BsonArray()));
+            }
+
+            BsonDocument results = new BsonDocument().append("results", new BsonArray(resultsArray));
+            String resultsString = results.toJson();
+            // Remove the prefix and suffix when writing to a file so only the [ ... ] array is included.
+            resultsString = resultsString.substring("{\"results\": ".length(), resultsString.length() - 1);
+
+            String resultsFilePath = "results.json";
+            try (OutputStreamWriter fileWriter = new OutputStreamWriter(new FileOutputStream(resultsFilePath), StandardCharsets.UTF_8)) {
+                fileWriter.write(resultsString);
+            }
+            System.out.println("Results written to file: " + resultsFilePath);
+        }
+    }
+}

data/ext/libmongocrypt/libmongocrypt/bindings/java/mongocrypt/benchmarks/src/main/resources/keyDocument.json

@@ -0,0 +1,24 @@
+{
+  "_id": {
+    "$binary": {
+      "base64": "YWFhYWFhYWFhYWFhYWFhYQ==",
+      "subType": "04"
+    }
+  },
+  "keyMaterial": {
+    "$binary": {
+      "base64": "ACR7Hm33dDOAAD7l2ubZhSpSUWK8BkALUY+qW3UgBAEcTV8sBwZnaAWnzDsmrX55dgmYHWfynDlJogC/e33u6pbhyXvFTs5ow9OLCuCWBJ39T/Ivm3kMaZJybkejY0V+uc4UEdHvVVz/SbitVnzs2WXdMGmo1/HmDRrxGYZjewFslquv8wtUHF5pyB+QDlQBd/al9M444/8bJZFbMSmtIg==",
+      "subType": "00"
+    }
+  },
+  "creationDate": {
+    "$date": "2023-08-21T14:28:20.875Z"
+  },
+  "updateDate": {
+    "$date": "2023-08-21T14:28:20.875Z"
+  },
+  "status": 0,
+  "masterKey": {
+    "provider": "local"
+  }
+}