From 0eba8edf541439d7bba4a74d9a03c78d7f2af527 Mon Sep 17 00:00:00 2001 From: Cheena Malhotra Date: Tue, 20 Oct 2026 22:51:28 -0700 Subject: [PATCH 1/2] Add asynchronous enclave delegate operations Connect enclave session lookup, attestation parameters, creation, and invalidation to async provider APIs without changing synchronous dispatch. Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> Copilot-Session: 4992e92c-122b-4f55-92c7-0042cd288dee --- .../Data/SqlClient/EnclaveDelegate.Crypto.cs | 78 +++ .../EnclaveDelegateAsyncTests.cs | 455 ++++++++++++++++++ 2 files changed, 533 insertions(+) create mode 100644 src/Microsoft.Data.SqlClient/tests/UnitTests/Microsoft/Data/SqlClient/AlwaysEncrypted/EnclaveDelegateAsyncTests.cs 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 8b461087bd..bae5e93e62 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,55 @@ 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 +135,19 @@ 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) { @@ -172,6 +236,20 @@ 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..d5f8d6b52c --- /dev/null +++ b/src/Microsoft.Data.SqlClient/tests/UnitTests/Microsoft/Data/SqlClient/AlwaysEncrypted/EnclaveDelegateAsyncTests.cs @@ -0,0 +1,455 @@ +// 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++; + } + } +} From a711d3c98f5c269ce376ade2cfbfbbf6b796113d Mon Sep 17 00:00:00 2001 From: Cheena Malhotra Date: Wed, 21 Oct 2026 10:14:11 -0700 Subject: [PATCH 2/2] Apply one-argument-per-line formatting to enclave delegate changes Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> Copilot-Session: 4992e92c-122b-4f55-92c7-0042cd288dee --- .../Data/SqlClient/EnclaveDelegate.Crypto.cs | 65 +++- .../EnclaveDelegateAsyncTests.cs | 331 ++++++++++++++---- 2 files changed, 315 insertions(+), 81 deletions(-) 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 bae5e93e62..e0a734678c 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 @@ -73,15 +73,23 @@ internal void GetEnclaveSession(SqlConnectionAttestationProtocol attestationProt /// 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) + 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) + enclaveSessionParameters, + generateCustomData: false, + isRetry, + cancellationToken) .ConfigureAwait(false); if (cached.SqlEnclaveSession != null) @@ -91,14 +99,19 @@ internal async Task CreateEnclaveSessionAsync( // 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) + attestationInfo, + attestationParameters.ClientDiffieHellmanKey, + enclaveSessionParameters, + customData, + customDataLength, + cancellationToken) .ConfigureAwait(false); if (created.SqlEnclaveSession == null) { throw SQL.NullEnclaveSessionReturnedFromProvider( - enclaveType, enclaveSessionParameters.AttestationUrl); + enclaveType, + enclaveSessionParameters.AttestationUrl); } } @@ -107,14 +120,20 @@ internal async Task CreateEnclaveSessionAsync( /// 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) + 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) + enclaveSessionParameters, + generateCustomData, + isRetry, + cancellationToken) .ConfigureAwait(false); } @@ -139,14 +158,18 @@ internal void InvalidateEnclaveSession(SqlConnectionAttestationProtocol attestat /// Invalidates a session through the provider's asynchronous API. /// internal async Task InvalidateEnclaveSessionAsync( - SqlConnectionAttestationProtocol attestationProtocol, string enclaveType, - EnclaveSessionParameters enclaveSessionParameters, SqlEnclaveSession enclaveSession, + 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); + enclaveSessionParameters, + enclaveSession, + cancellationToken).ConfigureAwait(false); } private SqlColumnEncryptionEnclaveProvider GetEnclaveProvider(SqlConnectionAttestationProtocol attestationProtocol, string enclaveType) @@ -240,14 +263,20 @@ internal SqlEnclaveAttestationParameters GetAttestationParameters(SqlConnectionA /// Obtains attestation parameters through the provider's asynchronous API. /// internal async Task GetAttestationParametersAsync( - SqlConnectionAttestationProtocol attestationProtocol, string enclaveType, - string attestationUrl, byte[] customData, int customDataLength, + 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); + attestationUrl, + customData, + customDataLength, + cancellationToken).ConfigureAwait(false); } internal byte[] GetSerializedAttestationParameters(SqlEnclaveAttestationParameters sqlEnclaveAttestationParameters, string enclaveType) 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 index d5f8d6b52c..0a8cfbc345 100644 --- 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 @@ -32,7 +32,11 @@ public async Task AsyncMethods_AwaitProviderOverrides() byte[] customData = { 1, 2 }; var lookup = new TaskCompletionSource<(SqlEnclaveSession, long, byte[], int)>( TaskCreationOptions.RunContinuationsAsynchronously); - provider.Lookup = (parameters, generate, retry, ct) => + provider.Lookup = ( + parameters, + generate, + retry, + ct) => { Assert.Same(registration.Parameters, parameters); Assert.True(generate); @@ -42,7 +46,12 @@ public async Task AsyncMethods_AwaitProviderOverrides() }; var lookupTask = EnclaveDelegate.Instance.GetEnclaveSessionAsync( - registration.Protocol, "VBS", registration.Parameters, true, true, token); + registration.Protocol, + "VBS", + registration.Parameters, + true, + true, + token); Assert.False(lookupTask.IsCompleted); lookup.SetResult((provider.Session, 42, customData, customData.Length)); var result = await lookupTask; @@ -53,7 +62,11 @@ public async Task AsyncMethods_AwaitProviderOverrides() var attestation = new TaskCompletionSource( TaskCreationOptions.RunContinuationsAsynchronously); - provider.Attest = (url, data, length, ct) => + provider.Attest = ( + url, + data, + length, + ct) => { Assert.Equal(registration.Parameters.AttestationUrl, url); Assert.Same(customData, data); @@ -63,17 +76,26 @@ public async Task AsyncMethods_AwaitProviderOverrides() }; Task attestationTask = EnclaveDelegate.Instance.GetAttestationParametersAsync( - registration.Protocol, "VBS", registration.Parameters.AttestationUrl, - customData, customData.Length, token); + registration.Protocol, + "VBS", + registration.Parameters.AttestationUrl, + customData, + customData.Length, + token); Assert.False(attestationTask.IsCompleted); SqlEnclaveAttestationParameters expected = new SqlEnclaveAttestationParameters( - 1, Array.Empty(), provider.Key); + 1, + Array.Empty(), + provider.Key); attestation.SetResult(expected); Assert.Same(expected, await attestationTask); var invalidation = new TaskCompletionSource( TaskCreationOptions.RunContinuationsAsynchronously); - provider.Invalidate = (parameters, session, ct) => + provider.Invalidate = ( + parameters, + session, + ct) => { Assert.Same(registration.Parameters, parameters); Assert.Same(provider.Session, session); @@ -81,7 +103,11 @@ public async Task AsyncMethods_AwaitProviderOverrides() return invalidation.Task; }; Task invalidationTask = EnclaveDelegate.Instance.InvalidateEnclaveSessionAsync( - registration.Protocol, "VBS", registration.Parameters, provider.Session, token); + registration.Protocol, + "VBS", + registration.Parameters, + provider.Session, + token); Assert.False(invalidationTask.IsCompleted); invalidation.SetResult(true); await invalidationTask; @@ -100,14 +126,21 @@ public async Task CreateEnclaveSessionAsync_RechecksCacheBeforeCreating() byte[] info = { 3 }; byte[] data = { 4, 5 }; using ECDiffieHellman key = ECDiffieHellman.Create(); - SqlEnclaveAttestationParameters attestation = new SqlEnclaveAttestationParameters(1, data, key); + 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) => + provider.Lookup = ( + parameters, + generate, + retry, + token) => { Assert.Same(registration.Parameters, parameters); Assert.False(generate); @@ -115,7 +148,13 @@ public async Task CreateEnclaveSessionAsync_RechecksCacheBeforeCreating() Assert.Equal(cancellation.Token, token); return lookup.Task; }; - provider.Create = (bytes, dh, parameters, custom, length, token) => + provider.Create = ( + bytes, + dh, + parameters, + custom, + length, + token) => { Assert.Same(info, bytes); Assert.Same(key, dh); @@ -128,18 +167,35 @@ public async Task CreateEnclaveSessionAsync_RechecksCacheBeforeCreating() }; Task task = EnclaveDelegate.Instance.CreateEnclaveSessionAsync( - registration.Protocol, "VBS", registration.Parameters, info, attestation, - data, data.Length, true, cancellation.Token); + 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) => + 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); + registration.Protocol, + "VBS", + registration.Parameters, + info, + null, + data, + data.Length, + false); Assert.True(warmTask.IsCompleted); await warmTask; Assert.Equal(1, provider.CreateCalls); @@ -147,8 +203,14 @@ public async Task CreateEnclaveSessionAsync_RechecksCacheBeforeCreating() await task; await EnclaveDelegate.Instance.CreateEnclaveSessionAsync( - registration.Protocol, "VBS", registration.Parameters, info, null, - data, data.Length, false); + registration.Protocol, + "VBS", + registration.Parameters, + info, + null, + data, + data.Length, + false); Assert.Equal(1, provider.CreateCalls); Assert.Equal(0, provider.SyncCalls); } @@ -163,14 +225,29 @@ public async Task CreateEnclaveSessionAsync_NullSessionMatchesSyncError() TestProvider provider = registration.Provider; provider.Session = null; SqlEnclaveAttestationParameters attestation = - new SqlEnclaveAttestationParameters(1, Array.Empty(), provider.Key); + 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)); + 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)); + registration.Protocol, + "VBS", + registration.Parameters, + Array.Empty(), + attestation, + null, + 0, + false)); Assert.NotNull(sync); Assert.NotNull(asyncError); Assert.Equal(sync.GetType(), asyncError.GetType()); @@ -190,7 +267,10 @@ 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)); + () => InvokeAsync( + registration, + operation, + token)); Assert.Equal(token, error.CancellationToken); Assert.Equal(0, registration.Provider.AsyncCalls); Assert.Equal(0, registration.Provider.SyncCalls); @@ -219,24 +299,44 @@ public async Task AsyncMethods_PropagateProviderFailures(int operation, bool can TestProvider provider = registration.Provider; if (operation == 0 || operation == 4) { - provider.Lookup = async (parameters, generate, retry, token) => + provider.Lookup = async ( + parameters, + generate, + retry, + token) => { await completion.Task; return (null, 0, null, 0); }; } - provider.Attest = async (url, data, length, token) => + provider.Attest = async ( + url, + data, + length, + token) => { await completion.Task; return null; }; - provider.Create = async (info, key, parameters, data, length, token) => + 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); + provider.Invalidate = ( + parameters, + session, + token) => completion.Task; + Task task = InvokeAsync( + registration, + operation, + cancellation.Token); Assert.False(task.IsCompleted); Exception expected; if (cancel) @@ -266,16 +366,35 @@ 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 _); + 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); + registration.Protocol, + "VBS", + registration.Parameters.AttestationUrl, + null, + 0); EnclaveDelegate.Instance.CreateEnclaveSession( - registration.Protocol, "VBS", registration.Parameters, Array.Empty(), - attestation, null, 0, false); + registration.Protocol, + "VBS", + registration.Parameters, + Array.Empty(), + attestation, + null, + 0, + false); EnclaveDelegate.Instance.InvalidateEnclaveSession( - registration.Protocol, "VBS", registration.Parameters, provider.Session); + registration.Protocol, + "VBS", + registration.Parameters, + provider.Session); Assert.Equal(5, provider.SyncCalls); Assert.Equal(0, provider.AsyncCalls); } @@ -293,10 +412,19 @@ 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 _)); + registration.Protocol, + "VBS", + registration.Parameters, + false, + false, + out _, + out _, + out _)); Exception asyncError = await Record.ExceptionAsync(() => - InvokeAsync(registration, operation, CancellationToken.None)); + InvokeAsync( + registration, + operation, + CancellationToken.None)); Assert.NotNull(sync); Assert.NotNull(asyncError); Assert.Equal(sync.GetType(), asyncError.GetType()); @@ -306,25 +434,51 @@ public async Task AsyncMethods_UnknownProtocolMatchesSyncError(int operation) /// /// Dispatches one delegate operation; operation four fails the creation cache recheck. /// - private static Task InvokeAsync(ProviderRegistration registration, int operation, CancellationToken token) + 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); + registration.Protocol, + "VBS", + registration.Parameters, + true, + false, + token); case 1: return EnclaveDelegate.Instance.GetAttestationParametersAsync( - registration.Protocol, "VBS", registration.Parameters.AttestationUrl, null, 0, token); + 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); + 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); + registration.Protocol, + "VBS", + registration.Parameters, + registration.Provider.Session, + token); } } @@ -344,7 +498,10 @@ private sealed class ProviderRegistration : IDisposable (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); + "unit.test.invalid", + "https://unit.test.invalid", + "database", + SqlConnectionAttestationProtocol.HGS); internal ProviderRegistration() { @@ -383,47 +540,85 @@ private sealed class TestProvider : SqlColumnEncryptionEnclaveProvider internal int CreateCalls; internal Func> Lookup = - (parameters, generate, retry, token) => Task.FromResult(((SqlEnclaveSession)null, 0L, (byte[])null, 0)); + ( + 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) + GetEnclaveSessionAsync( + EnclaveSessionParameters parameters, + bool generateCustomData, + bool isRetry, + CancellationToken cancellationToken = default) { AsyncCalls++; - return Lookup(parameters, generateCustomData, isRetry, cancellationToken); + return Lookup( + parameters, + generateCustomData, + isRetry, + cancellationToken); } internal override Task GetAttestationParametersAsync( - string url, byte[] customData, int customDataLength, CancellationToken cancellationToken = default) + string url, + byte[] customData, + int customDataLength, + CancellationToken cancellationToken = default) { AsyncCalls++; - return Attest(url, customData, customDataLength, cancellationToken); + 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) + 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); + Create( + info, + key, + parameters, + customData, + customDataLength, + cancellationToken); } internal override Task InvalidateEnclaveSessionAsync( - EnclaveSessionParameters parameters, SqlEnclaveSession session, CancellationToken cancellationToken = default) + EnclaveSessionParameters parameters, + SqlEnclaveSession session, + CancellationToken cancellationToken = default) { AsyncCalls++; - return Invalidate(parameters, session, cancellationToken); + 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) + EnclaveSessionParameters parameters, + bool generateCustomData, + bool isRetry, + out SqlEnclaveSession session, + out long counter, + out byte[] customData, + out int customDataLength) { SyncCalls++; session = null; @@ -433,15 +628,25 @@ internal override void GetEnclaveSession( } internal override SqlEnclaveAttestationParameters GetAttestationParameters( - string url, byte[] customData, int customDataLength) + string url, + byte[] customData, + int customDataLength) { SyncCalls++; - return new SqlEnclaveAttestationParameters(1, Array.Empty(), Key); + 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) + byte[] info, + ECDiffieHellman key, + EnclaveSessionParameters parameters, + byte[] customData, + int customDataLength, + out SqlEnclaveSession session, + out long counter) { SyncCalls++; session = Session;