diff --git a/src/Microsoft.Data.SqlClient/src/Microsoft/Data/SqlClient/EnclaveDelegate.Crypto.cs b/src/Microsoft.Data.SqlClient/src/Microsoft/Data/SqlClient/EnclaveDelegate.Crypto.cs
index 876fcb62f2..2ece42d648 100644
--- a/src/Microsoft.Data.SqlClient/src/Microsoft/Data/SqlClient/EnclaveDelegate.Crypto.cs
+++ b/src/Microsoft.Data.SqlClient/src/Microsoft/Data/SqlClient/EnclaveDelegate.Crypto.cs
@@ -5,6 +5,8 @@
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
namespace Microsoft.Data.SqlClient
{
@@ -67,6 +69,74 @@ internal void GetEnclaveSession(SqlConnectionAttestationProtocol attestationProt
GetEnclaveSession(attestationProtocol, enclaveType, enclaveSessionParameters, generateCustomData, isRetry, out sqlEnclaveSession, out _, out customData, out customDataLength, throwIfNull: false);
}
+ ///
+ /// Creates a session asynchronously, unless another caller has already cached one.
+ ///
+ internal async Task CreateEnclaveSessionAsync(
+ SqlConnectionAttestationProtocol attestationProtocol,
+ string enclaveType,
+ EnclaveSessionParameters enclaveSessionParameters,
+ byte[] attestationInfo,
+ SqlEnclaveAttestationParameters attestationParameters,
+ byte[] customData,
+ int customDataLength,
+ bool isRetry,
+ CancellationToken cancellationToken = default)
+ {
+ cancellationToken.ThrowIfCancellationRequested();
+ SqlColumnEncryptionEnclaveProvider provider = GetEnclaveProvider(attestationProtocol, enclaveType);
+ var cached = await provider.GetEnclaveSessionAsync(
+ enclaveSessionParameters,
+ generateCustomData: false,
+ isRetry,
+ cancellationToken)
+ .ConfigureAwait(false);
+
+ if (cached.SqlEnclaveSession != null)
+ {
+ return;
+ }
+
+ // The provider owns the async attestation gate and rechecks its cache under that gate.
+ var created = await provider.CreateEnclaveSessionAsync(
+ attestationInfo,
+ attestationParameters.ClientDiffieHellmanKey,
+ enclaveSessionParameters,
+ customData,
+ customDataLength,
+ cancellationToken)
+ .ConfigureAwait(false);
+
+ if (created.SqlEnclaveSession == null)
+ {
+ throw SQL.NullEnclaveSessionReturnedFromProvider(
+ enclaveType,
+ enclaveSessionParameters.AttestationUrl);
+ }
+ }
+
+ ///
+ /// Looks up a session asynchronously, preserving its replay counter and attestation data.
+ ///
+ internal async Task<(SqlEnclaveSession SqlEnclaveSession, long Counter, byte[] CustomData, int CustomDataLength)>
+ GetEnclaveSessionAsync(
+ SqlConnectionAttestationProtocol attestationProtocol,
+ string enclaveType,
+ EnclaveSessionParameters enclaveSessionParameters,
+ bool generateCustomData,
+ bool isRetry,
+ CancellationToken cancellationToken = default)
+ {
+ cancellationToken.ThrowIfCancellationRequested();
+ SqlColumnEncryptionEnclaveProvider provider = GetEnclaveProvider(attestationProtocol, enclaveType);
+ return await provider.GetEnclaveSessionAsync(
+ enclaveSessionParameters,
+ generateCustomData,
+ isRetry,
+ cancellationToken)
+ .ConfigureAwait(false);
+ }
+
private void GetEnclaveSession(SqlConnectionAttestationProtocol attestationProtocol, string enclaveType, EnclaveSessionParameters enclaveSessionParameters, bool generateCustomData, bool isRetry, out SqlEnclaveSession sqlEnclaveSession, out long counter, out byte[] customData, out int customDataLength, bool throwIfNull)
{
SqlColumnEncryptionEnclaveProvider sqlColumnEncryptionEnclaveProvider = GetEnclaveProvider(attestationProtocol, enclaveType);
@@ -84,6 +154,23 @@ internal void InvalidateEnclaveSession(SqlConnectionAttestationProtocol attestat
sqlColumnEncryptionEnclaveProvider.InvalidateEnclaveSession(enclaveSessionParameters, enclaveSession);
}
+ ///
+ /// Invalidates a session through the provider's asynchronous API.
+ ///
+ internal async Task InvalidateEnclaveSessionAsync(
+ SqlConnectionAttestationProtocol attestationProtocol,
+ string enclaveType,
+ EnclaveSessionParameters enclaveSessionParameters,
+ SqlEnclaveSession enclaveSession,
+ CancellationToken cancellationToken = default)
+ {
+ cancellationToken.ThrowIfCancellationRequested();
+ SqlColumnEncryptionEnclaveProvider provider = GetEnclaveProvider(attestationProtocol, enclaveType);
+ await provider.InvalidateEnclaveSessionAsync(
+ enclaveSessionParameters,
+ enclaveSession,
+ cancellationToken).ConfigureAwait(false);
+ }
private SqlColumnEncryptionEnclaveProvider GetEnclaveProvider(SqlConnectionAttestationProtocol attestationProtocol, string enclaveType)
{
@@ -178,6 +265,26 @@ internal SqlEnclaveAttestationParameters GetAttestationParameters(SqlConnectionA
return sqlColumnEncryptionEnclaveProvider.GetAttestationParameters(attestationUrl, customData, customDataLength);
}
+ ///
+ /// Obtains attestation parameters through the provider's asynchronous API.
+ ///
+ internal async Task GetAttestationParametersAsync(
+ SqlConnectionAttestationProtocol attestationProtocol,
+ string enclaveType,
+ string attestationUrl,
+ byte[] customData,
+ int customDataLength,
+ CancellationToken cancellationToken = default)
+ {
+ cancellationToken.ThrowIfCancellationRequested();
+ SqlColumnEncryptionEnclaveProvider provider = GetEnclaveProvider(attestationProtocol, enclaveType);
+ return await provider.GetAttestationParametersAsync(
+ attestationUrl,
+ customData,
+ customDataLength,
+ cancellationToken).ConfigureAwait(false);
+ }
+
internal byte[] GetSerializedAttestationParameters(SqlEnclaveAttestationParameters sqlEnclaveAttestationParameters, string enclaveType)
{
byte[] attestationProtocolBytes = null;
diff --git a/src/Microsoft.Data.SqlClient/tests/UnitTests/Microsoft/Data/SqlClient/AlwaysEncrypted/EnclaveDelegateAsyncTests.cs b/src/Microsoft.Data.SqlClient/tests/UnitTests/Microsoft/Data/SqlClient/AlwaysEncrypted/EnclaveDelegateAsyncTests.cs
new file mode 100644
index 0000000000..0a8cfbc345
--- /dev/null
+++ b/src/Microsoft.Data.SqlClient/tests/UnitTests/Microsoft/Data/SqlClient/AlwaysEncrypted/EnclaveDelegateAsyncTests.cs
@@ -0,0 +1,660 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#nullable disable
+
+using System;
+using System.Collections.Concurrent;
+using System.Reflection;
+using System.Security.Cryptography;
+using System.Threading;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace Microsoft.Data.SqlClient.UnitTests.AlwaysEncrypted
+{
+ ///
+ /// Verifies delegate dispatch, cache rechecks, and sync/async parity without network attestation.
+ ///
+ public class EnclaveDelegateAsyncTests
+ {
+ ///
+ /// Incomplete provider tasks must be awaited and their inputs and results preserved.
+ ///
+ [Fact]
+ public async Task AsyncMethods_AwaitProviderOverrides()
+ {
+ using ProviderRegistration registration = new ProviderRegistration();
+ TestProvider provider = registration.Provider;
+ using CancellationTokenSource cancellation = new CancellationTokenSource();
+ CancellationToken token = cancellation.Token;
+ byte[] customData = { 1, 2 };
+ var lookup = new TaskCompletionSource<(SqlEnclaveSession, long, byte[], int)>(
+ TaskCreationOptions.RunContinuationsAsynchronously);
+ provider.Lookup = (
+ parameters,
+ generate,
+ retry,
+ ct) =>
+ {
+ Assert.Same(registration.Parameters, parameters);
+ Assert.True(generate);
+ Assert.True(retry);
+ Assert.Equal(token, ct);
+ return lookup.Task;
+ };
+
+ var lookupTask = EnclaveDelegate.Instance.GetEnclaveSessionAsync(
+ registration.Protocol,
+ "VBS",
+ registration.Parameters,
+ true,
+ true,
+ token);
+ Assert.False(lookupTask.IsCompleted);
+ lookup.SetResult((provider.Session, 42, customData, customData.Length));
+ var result = await lookupTask;
+ Assert.Same(provider.Session, result.SqlEnclaveSession);
+ Assert.Equal(42, result.Counter);
+ Assert.Same(customData, result.CustomData);
+ Assert.Equal(customData.Length, result.CustomDataLength);
+
+ var attestation = new TaskCompletionSource(
+ TaskCreationOptions.RunContinuationsAsynchronously);
+ provider.Attest = (
+ url,
+ data,
+ length,
+ ct) =>
+ {
+ Assert.Equal(registration.Parameters.AttestationUrl, url);
+ Assert.Same(customData, data);
+ Assert.Equal(customData.Length, length);
+ Assert.Equal(token, ct);
+ return attestation.Task;
+ };
+ Task attestationTask =
+ EnclaveDelegate.Instance.GetAttestationParametersAsync(
+ registration.Protocol,
+ "VBS",
+ registration.Parameters.AttestationUrl,
+ customData,
+ customData.Length,
+ token);
+ Assert.False(attestationTask.IsCompleted);
+ SqlEnclaveAttestationParameters expected = new SqlEnclaveAttestationParameters(
+ 1,
+ Array.Empty(),
+ provider.Key);
+ attestation.SetResult(expected);
+ Assert.Same(expected, await attestationTask);
+
+ var invalidation = new TaskCompletionSource(
+ TaskCreationOptions.RunContinuationsAsynchronously);
+ provider.Invalidate = (
+ parameters,
+ session,
+ ct) =>
+ {
+ Assert.Same(registration.Parameters, parameters);
+ Assert.Same(provider.Session, session);
+ Assert.Equal(token, ct);
+ return invalidation.Task;
+ };
+ Task invalidationTask = EnclaveDelegate.Instance.InvalidateEnclaveSessionAsync(
+ registration.Protocol,
+ "VBS",
+ registration.Parameters,
+ provider.Session,
+ token);
+ Assert.False(invalidationTask.IsCompleted);
+ invalidation.SetResult(true);
+ await invalidationTask;
+ Assert.Equal(0, provider.SyncCalls);
+ }
+
+ ///
+ /// Cold creation awaits the async cache probe and attestation; warm creation skips attestation.
+ ///
+ [Fact]
+ public async Task CreateEnclaveSessionAsync_RechecksCacheBeforeCreating()
+ {
+ using ProviderRegistration registration = new ProviderRegistration();
+ TestProvider provider = registration.Provider;
+ using CancellationTokenSource cancellation = new CancellationTokenSource();
+ byte[] info = { 3 };
+ byte[] data = { 4, 5 };
+ using ECDiffieHellman key = ECDiffieHellman.Create();
+ SqlEnclaveAttestationParameters attestation = new SqlEnclaveAttestationParameters(
+ 1,
+ data,
+ key);
+ var lookup = new TaskCompletionSource<(SqlEnclaveSession, long, byte[], int)>(
+ TaskCreationOptions.RunContinuationsAsynchronously);
+ var creation = new TaskCompletionSource<(SqlEnclaveSession, long)>(
+ TaskCreationOptions.RunContinuationsAsynchronously);
+ var creationEntered = new TaskCompletionSource(
+ TaskCreationOptions.RunContinuationsAsynchronously);
+ provider.Lookup = (
+ parameters,
+ generate,
+ retry,
+ token) =>
+ {
+ Assert.Same(registration.Parameters, parameters);
+ Assert.False(generate);
+ Assert.True(retry);
+ Assert.Equal(cancellation.Token, token);
+ return lookup.Task;
+ };
+ provider.Create = (
+ bytes,
+ dh,
+ parameters,
+ custom,
+ length,
+ token) =>
+ {
+ Assert.Same(info, bytes);
+ Assert.Same(key, dh);
+ Assert.Same(registration.Parameters, parameters);
+ Assert.Same(data, custom);
+ Assert.Equal(data.Length, length);
+ Assert.Equal(cancellation.Token, token);
+ creationEntered.SetResult(true);
+ return creation.Task;
+ };
+
+ Task task = EnclaveDelegate.Instance.CreateEnclaveSessionAsync(
+ registration.Protocol,
+ "VBS",
+ registration.Parameters,
+ info,
+ attestation,
+ data,
+ data.Length,
+ true,
+ cancellation.Token);
+ Assert.False(task.IsCompleted);
+ Assert.Equal(0, provider.CreateCalls);
+ lookup.SetResult((null, 0, null, 0));
+ await await Task.WhenAny(creationEntered.Task, task);
+ Assert.False(task.IsCompleted);
+ provider.Lookup = (
+ parameters,
+ generate,
+ retry,
+ token) =>
+ Task.FromResult((provider.Session, 2L, (byte[])null, 0));
+ Task warmTask = EnclaveDelegate.Instance.CreateEnclaveSessionAsync(
+ registration.Protocol,
+ "VBS",
+ registration.Parameters,
+ info,
+ null,
+ data,
+ data.Length,
+ false);
+ Assert.True(warmTask.IsCompleted);
+ await warmTask;
+ Assert.Equal(1, provider.CreateCalls);
+ creation.SetResult((provider.Session, 1));
+ await task;
+
+ await EnclaveDelegate.Instance.CreateEnclaveSessionAsync(
+ registration.Protocol,
+ "VBS",
+ registration.Parameters,
+ info,
+ null,
+ data,
+ data.Length,
+ false);
+ Assert.Equal(1, provider.CreateCalls);
+ Assert.Equal(0, provider.SyncCalls);
+ }
+
+ ///
+ /// A provider returning no newly created session retains the synchronous validation error.
+ ///
+ [Fact]
+ public async Task CreateEnclaveSessionAsync_NullSessionMatchesSyncError()
+ {
+ using ProviderRegistration registration = new ProviderRegistration();
+ TestProvider provider = registration.Provider;
+ provider.Session = null;
+ SqlEnclaveAttestationParameters attestation =
+ new SqlEnclaveAttestationParameters(
+ 1,
+ Array.Empty(),
+ provider.Key);
+ Exception sync = Record.Exception(() => EnclaveDelegate.Instance.CreateEnclaveSession(
+ registration.Protocol,
+ "VBS",
+ registration.Parameters,
+ Array.Empty(),
+ attestation,
+ null,
+ 0,
+ false));
+ Exception asyncError = await Record.ExceptionAsync(() =>
+ EnclaveDelegate.Instance.CreateEnclaveSessionAsync(
+ registration.Protocol,
+ "VBS",
+ registration.Parameters,
+ Array.Empty(),
+ attestation,
+ null,
+ 0,
+ false));
+ Assert.NotNull(sync);
+ Assert.NotNull(asyncError);
+ Assert.Equal(sync.GetType(), asyncError.GetType());
+ Assert.Equal(sync.Message, asyncError.Message);
+ }
+
+ ///
+ /// Every async operation rejects pre-cancellation without invoking any provider method.
+ ///
+ [Theory]
+ [InlineData(0)]
+ [InlineData(1)]
+ [InlineData(2)]
+ [InlineData(3)]
+ public async Task AsyncMethods_PreCanceled_DoNotInvokeProvider(int operation)
+ {
+ using ProviderRegistration registration = new ProviderRegistration();
+ CancellationToken token = new CancellationToken(true);
+ OperationCanceledException error = await Assert.ThrowsAnyAsync(
+ () => InvokeAsync(
+ registration,
+ operation,
+ token));
+ Assert.Equal(token, error.CancellationToken);
+ Assert.Equal(0, registration.Provider.AsyncCalls);
+ Assert.Equal(0, registration.Provider.SyncCalls);
+ }
+
+ ///
+ /// Provider failures and in-flight cancellation escape unchanged, never as retryable errors.
+ ///
+ [Theory]
+ [InlineData(0, false)]
+ [InlineData(1, false)]
+ [InlineData(2, false)]
+ [InlineData(3, false)]
+ [InlineData(4, false)]
+ [InlineData(0, true)]
+ [InlineData(1, true)]
+ [InlineData(2, true)]
+ [InlineData(3, true)]
+ [InlineData(4, true)]
+ public async Task AsyncMethods_PropagateProviderFailures(int operation, bool cancel)
+ {
+ using ProviderRegistration registration = new ProviderRegistration();
+ using CancellationTokenSource cancellation = new CancellationTokenSource();
+ var completion = new TaskCompletionSource(
+ TaskCreationOptions.RunContinuationsAsynchronously);
+ TestProvider provider = registration.Provider;
+ if (operation == 0 || operation == 4)
+ {
+ provider.Lookup = async (
+ parameters,
+ generate,
+ retry,
+ token) =>
+ {
+ await completion.Task;
+ return (null, 0, null, 0);
+ };
+ }
+ provider.Attest = async (
+ url,
+ data,
+ length,
+ token) =>
+ {
+ await completion.Task;
+ return null;
+ };
+ provider.Create = async (
+ info,
+ key,
+ parameters,
+ data,
+ length,
+ token) =>
+ {
+ await completion.Task;
+ return (null, 0);
+ };
+ provider.Invalidate = (
+ parameters,
+ session,
+ token) => completion.Task;
+ Task task = InvokeAsync(
+ registration,
+ operation,
+ cancellation.Token);
+ Assert.False(task.IsCompleted);
+ Exception expected;
+ if (cancel)
+ {
+ cancellation.Cancel();
+ expected = new OperationCanceledException(cancellation.Token);
+ }
+ else
+ {
+ expected = new InvalidOperationException("Provider failure");
+ }
+ completion.SetException(expected);
+ Assert.Same(expected, await Record.ExceptionAsync(() => task));
+ Assert.Equal(cancel, task.IsCanceled);
+ if (operation == 4)
+ {
+ Assert.Equal(0, provider.CreateCalls);
+ }
+ }
+
+ ///
+ /// Existing synchronous delegate methods continue dispatching only synchronous provider APIs.
+ ///
+ [Fact]
+ public void SyncMethods_KeepSynchronousDispatch()
+ {
+ using ProviderRegistration registration = new ProviderRegistration();
+ TestProvider provider = registration.Provider;
+ EnclaveDelegate.Instance.GetEnclaveSession(
+ registration.Protocol,
+ "VBS",
+ registration.Parameters,
+ false,
+ false,
+ out SqlEnclaveSession session,
+ out _,
+ out _);
+ Assert.Null(session);
+ SqlEnclaveAttestationParameters attestation = EnclaveDelegate.Instance.GetAttestationParameters(
+ registration.Protocol,
+ "VBS",
+ registration.Parameters.AttestationUrl,
+ null,
+ 0);
+ EnclaveDelegate.Instance.CreateEnclaveSession(
+ registration.Protocol,
+ "VBS",
+ registration.Parameters,
+ Array.Empty(),
+ attestation,
+ null,
+ 0,
+ false);
+ EnclaveDelegate.Instance.InvalidateEnclaveSession(
+ registration.Protocol,
+ "VBS",
+ registration.Parameters,
+ provider.Session);
+ Assert.Equal(5, provider.SyncCalls);
+ Assert.Equal(0, provider.AsyncCalls);
+ }
+
+ ///
+ /// Unknown protocols retain the synchronous provider-resolution error on every async entry.
+ ///
+ [Theory]
+ [InlineData(0)]
+ [InlineData(1)]
+ [InlineData(2)]
+ [InlineData(3)]
+ public async Task AsyncMethods_UnknownProtocolMatchesSyncError(int operation)
+ {
+ using ProviderRegistration registration = new ProviderRegistration();
+ registration.Unregister();
+ Exception sync = Record.Exception(() => EnclaveDelegate.Instance.GetEnclaveSession(
+ registration.Protocol,
+ "VBS",
+ registration.Parameters,
+ false,
+ false,
+ out _,
+ out _,
+ out _));
+ Exception asyncError = await Record.ExceptionAsync(() =>
+ InvokeAsync(
+ registration,
+ operation,
+ CancellationToken.None));
+ Assert.NotNull(sync);
+ Assert.NotNull(asyncError);
+ Assert.Equal(sync.GetType(), asyncError.GetType());
+ Assert.Equal(sync.Message, asyncError.Message);
+ }
+
+ ///
+ /// Dispatches one delegate operation; operation four fails the creation cache recheck.
+ ///
+ private static Task InvokeAsync(
+ ProviderRegistration registration,
+ int operation,
+ CancellationToken token)
+ {
+ switch (operation)
+ {
+ case 0:
+ return EnclaveDelegate.Instance.GetEnclaveSessionAsync(
+ registration.Protocol,
+ "VBS",
+ registration.Parameters,
+ true,
+ false,
+ token);
+ case 1:
+ return EnclaveDelegate.Instance.GetAttestationParametersAsync(
+ registration.Protocol,
+ "VBS",
+ registration.Parameters.AttestationUrl,
+ null,
+ 0,
+ token);
+ case 2:
+ case 4:
+ return EnclaveDelegate.Instance.CreateEnclaveSessionAsync(
+ registration.Protocol,
+ "VBS",
+ registration.Parameters,
+ Array.Empty(),
+ new SqlEnclaveAttestationParameters(
+ 1,
+ Array.Empty(),
+ registration.Provider.Key),
+ null,
+ 0,
+ false,
+ token);
+ default:
+ return EnclaveDelegate.Instance.InvalidateEnclaveSessionAsync(
+ registration.Protocol,
+ "VBS",
+ registration.Parameters,
+ registration.Provider.Session,
+ token);
+ }
+ }
+
+ ///
+ /// Registers an isolated test-only protocol without replacing built-in providers or their caches.
+ ///
+ private sealed class ProviderRegistration : IDisposable
+ {
+ private static int s_protocol = int.MaxValue;
+ private bool _registered;
+ private readonly ConcurrentDictionary _providers =
+ (ConcurrentDictionary)
+ typeof(EnclaveDelegate).GetField("s_enclaveProviders", BindingFlags.NonPublic | BindingFlags.Static)
+ .GetValue(null);
+
+ internal readonly SqlConnectionAttestationProtocol Protocol =
+ (SqlConnectionAttestationProtocol)Interlocked.Decrement(ref s_protocol);
+ internal readonly TestProvider Provider = new TestProvider();
+ internal readonly EnclaveSessionParameters Parameters = new EnclaveSessionParameters(
+ "unit.test.invalid",
+ "https://unit.test.invalid",
+ "database",
+ SqlConnectionAttestationProtocol.HGS);
+
+ internal ProviderRegistration()
+ {
+ Assert.True(_providers.TryAdd(Protocol, Provider));
+ _registered = true;
+ }
+
+ ///
+ /// Removes only this fixture's protocol so provider-resolution failures can be exercised.
+ ///
+ internal void Unregister()
+ {
+ Assert.True(_providers.TryRemove(Protocol, out _));
+ _registered = false;
+ }
+
+ public void Dispose()
+ {
+ if (_registered)
+ {
+ Unregister();
+ }
+ Provider.Key.Dispose();
+ }
+ }
+
+ ///
+ /// Separates synchronous dispatch from controllable, genuinely asynchronous provider operations.
+ ///
+ private sealed class TestProvider : SqlColumnEncryptionEnclaveProvider
+ {
+ internal readonly ECDiffieHellman Key = ECDiffieHellman.Create();
+ internal SqlEnclaveSession Session = new SqlEnclaveSession(new byte[] { 1, 2, 3 }, 1);
+ internal int SyncCalls;
+ internal int AsyncCalls;
+ internal int CreateCalls;
+ internal Func> Lookup =
+ (
+ parameters,
+ generate,
+ retry,
+ token) => Task.FromResult(((SqlEnclaveSession)null, 0L, (byte[])null, 0));
+ internal Func> Attest;
+ internal Func> Create;
+ internal Func Invalidate;
+
+ internal override Task<(SqlEnclaveSession SqlEnclaveSession, long Counter, byte[] CustomData, int CustomDataLength)>
+ GetEnclaveSessionAsync(
+ EnclaveSessionParameters parameters,
+ bool generateCustomData,
+ bool isRetry,
+ CancellationToken cancellationToken = default)
+ {
+ AsyncCalls++;
+ return Lookup(
+ parameters,
+ generateCustomData,
+ isRetry,
+ cancellationToken);
+ }
+
+ internal override Task GetAttestationParametersAsync(
+ string url,
+ byte[] customData,
+ int customDataLength,
+ CancellationToken cancellationToken = default)
+ {
+ AsyncCalls++;
+ return Attest(
+ url,
+ customData,
+ customDataLength,
+ cancellationToken);
+ }
+
+ internal override Task<(SqlEnclaveSession SqlEnclaveSession, long Counter)> CreateEnclaveSessionAsync(
+ byte[] info,
+ ECDiffieHellman key,
+ EnclaveSessionParameters parameters,
+ byte[] customData,
+ int customDataLength,
+ CancellationToken cancellationToken = default)
+ {
+ AsyncCalls++;
+ CreateCalls++;
+ return Create == null ? Task.FromResult((Session, 1L)) :
+ Create(
+ info,
+ key,
+ parameters,
+ customData,
+ customDataLength,
+ cancellationToken);
+ }
+
+ internal override Task InvalidateEnclaveSessionAsync(
+ EnclaveSessionParameters parameters,
+ SqlEnclaveSession session,
+ CancellationToken cancellationToken = default)
+ {
+ AsyncCalls++;
+ return Invalidate(
+ parameters,
+ session,
+ cancellationToken);
+ }
+
+ internal override void GetEnclaveSession(
+ EnclaveSessionParameters parameters,
+ bool generateCustomData,
+ bool isRetry,
+ out SqlEnclaveSession session,
+ out long counter,
+ out byte[] customData,
+ out int customDataLength)
+ {
+ SyncCalls++;
+ session = null;
+ counter = 0;
+ customData = null;
+ customDataLength = 0;
+ }
+
+ internal override SqlEnclaveAttestationParameters GetAttestationParameters(
+ string url,
+ byte[] customData,
+ int customDataLength)
+ {
+ SyncCalls++;
+ return new SqlEnclaveAttestationParameters(
+ 1,
+ Array.Empty(),
+ Key);
+ }
+
+ internal override void CreateEnclaveSession(
+ byte[] info,
+ ECDiffieHellman key,
+ EnclaveSessionParameters parameters,
+ byte[] customData,
+ int customDataLength,
+ out SqlEnclaveSession session,
+ out long counter)
+ {
+ SyncCalls++;
+ session = Session;
+ counter = 1;
+ }
+
+ internal override void InvalidateEnclaveSession(EnclaveSessionParameters parameters, SqlEnclaveSession session)
+ => SyncCalls++;
+ }
+ }
+}