fix: deadlock when used in synchronous context (FantasticFiasco#545)

Fixes FantasticFiasco#543
acurrieebix · Mar 25, 2022 · 2ca5a34 · 2ca5a34
1 parent 7376ca4
commit 2ca5a34
Show file tree

Hide file tree

Showing 11 changed files with 108 additions and 84 deletions.
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -6,6 +6,10 @@ This project adheres to [Semantic Versioning](http://semver.org/) and is followi
 
 ## Unreleased
 
+### :syringe: Fixed
+
+- [#543](https://github.com/FantasticFiasco/aws-signature-version-4/issues/543) Deadlock when used in synchronous context (contribution by [@ronenfe](https://github.com/ronenfe))
+
 ## [3.0.0] - 2022-03-18
 
 ### :zap: Added

diff --git a/src/AwsSignatureHandler.cs b/src/AwsSignatureHandler.cs
@@ -44,18 +44,20 @@ protected override async Task<HttpResponseMessage> SendAsync(
         {
             RemoveHeaders(request);
 
-            var immutableCredentials = await settings.Credentials.GetCredentialsAsync();
+            var immutableCredentials = await settings.Credentials.GetCredentialsAsync().ConfigureAwait(false);
 
-            await Signer.SignAsync(
-                request,
-                null,
-                EmptyRequestHeaders,
-                DateTime.UtcNow,
-                settings.RegionName,
-                settings.ServiceName,
-                immutableCredentials);
+            await Signer
+                .SignAsync(
+                    request,
+                    null,
+                    EmptyRequestHeaders,
+                    DateTime.UtcNow,
+                    settings.RegionName,
+                    settings.ServiceName,
+                    immutableCredentials)
+                .ConfigureAwait(false);
 
-            return await base.SendAsync(request, cancellationToken);
+            return await base.SendAsync(request, cancellationToken).ConfigureAwait(false);
         }
 
 #if NET5_0_OR_GREATER

diff --git a/src/DeleteAsyncExtensions.cs b/src/DeleteAsyncExtensions.cs
@@ -387,14 +387,16 @@ public static async Task<HttpResponseMessage> DeleteAsync(
         {
             if (credentials == null) throw new ArgumentNullException(nameof(credentials));
 
-            var immutableCredentials = await credentials.GetCredentialsAsync();
+            var immutableCredentials = await credentials.GetCredentialsAsync().ConfigureAwait(false);
 
-            var response = await self.DeleteAsync(
-                requestUri,
-                regionName,
-                serviceName,
-                immutableCredentials,
-                cancellationToken);
+            var response = await self
+                .DeleteAsync(
+                    requestUri,
+                    regionName,
+                    serviceName,
+                    immutableCredentials,
+                    cancellationToken)
+                .ConfigureAwait(false);
 
             return response;
         }

diff --git a/src/GetAsyncExtensions.cs b/src/GetAsyncExtensions.cs
@@ -886,15 +886,17 @@ public static async Task<HttpResponseMessage> GetAsync(
         {
             if (credentials == null) throw new ArgumentNullException(nameof(credentials));
 
-            var immutableCredentials = await credentials.GetCredentialsAsync();
-
-            var response = await self.GetAsync(
-                requestUri,
-                completionOption,
-                regionName,
-                serviceName,
-                immutableCredentials,
-                cancellationToken);
+            var immutableCredentials = await credentials.GetCredentialsAsync().ConfigureAwait(false);
+
+            var response = await self
+                .GetAsync(
+                    requestUri,
+                    completionOption,
+                    regionName,
+                    serviceName,
+                    immutableCredentials,
+                    cancellationToken)
+                .ConfigureAwait(false);
 
             return response;
         }

diff --git a/src/GetStringAsyncExtensions.cs b/src/GetStringAsyncExtensions.cs
@@ -387,14 +387,16 @@ public static async Task<string> GetStringAsync(
         {
             if (credentials == null) throw new ArgumentNullException(nameof(credentials));
 
-            var immutableCredentials = await credentials.GetCredentialsAsync();
+            var immutableCredentials = await credentials.GetCredentialsAsync().ConfigureAwait(false);
 
-            var result = await self.GetStringAsync(
-                requestUri,
-                regionName,
-                serviceName,
-                immutableCredentials,
-                cancellationToken);
+            var result = await self
+                .GetStringAsync(
+                    requestUri,
+                    regionName,
+                    serviceName,
+                    immutableCredentials,
+                    cancellationToken)
+                .ConfigureAwait(false);
 
             return result;
         }
@@ -448,12 +450,14 @@ public static async Task<string> GetStringAsync(
             ImmutableCredentials credentials,
             CancellationToken cancellationToken)
         {
-            using var response = await self.GetAsync(
-                requestUri,
-                regionName,
-                serviceName,
-                credentials,
-                cancellationToken);
+            using var response = await self
+                .GetAsync(
+                    requestUri,
+                    regionName,
+                    serviceName,
+                    credentials,
+                    cancellationToken)
+                .ConfigureAwait(false);
 
             response.EnsureSuccessStatusCode();
 
@@ -464,9 +468,9 @@ public static async Task<string> GetStringAsync(
             }
 
 #if NET5_0_OR_GREATER
-            return await content.ReadAsStringAsync(cancellationToken);
+            return await content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
 #else
-            return await content.ReadAsStringAsync();
+            return await content.ReadAsStringAsync().ConfigureAwait(false);
 #endif
         }
 

diff --git a/src/PatchAsyncExtensions.cs b/src/PatchAsyncExtensions.cs
@@ -427,15 +427,17 @@ public static async Task<HttpResponseMessage> PatchAsync(
         {
             if (credentials == null) throw new ArgumentNullException(nameof(credentials));
 
-            var immutableCredentials = await credentials.GetCredentialsAsync();
+            var immutableCredentials = await credentials.GetCredentialsAsync().ConfigureAwait(false);
 
-            var response = await self.PatchAsync(
-                requestUri,
-                content,
-                regionName,
-                serviceName,
-                immutableCredentials,
-                cancellationToken);
+            var response = await self
+                .PatchAsync(
+                    requestUri,
+                    content,
+                    regionName,
+                    serviceName,
+                    immutableCredentials,
+                    cancellationToken)
+                .ConfigureAwait(false);
 
             return response;
         }

diff --git a/src/PostAsyncExtensions.cs b/src/PostAsyncExtensions.cs
@@ -421,15 +421,17 @@ public static async Task<HttpResponseMessage> PostAsync(
         {
             if (credentials == null) throw new ArgumentNullException(nameof(credentials));
 
-            var immutableCredentials = await credentials.GetCredentialsAsync();
+            var immutableCredentials = await credentials.GetCredentialsAsync().ConfigureAwait(false);
 
-            var response = await self.PostAsync(
-                requestUri,
-                content,
-                regionName,
-                serviceName,
-                immutableCredentials,
-                cancellationToken);
+            var response = await self
+                .PostAsync(
+                    requestUri,
+                    content,
+                    regionName,
+                    serviceName,
+                    immutableCredentials,
+                    cancellationToken)
+                .ConfigureAwait(false);
 
             return response;
         }

diff --git a/src/Private/ContentHash.cs b/src/Private/ContentHash.cs
@@ -25,7 +25,7 @@ public static async Task<string> CalculateAsync(HttpContent? content)
                 return AWS4Signer.EmptyBodySha256;
             }
 
-            var contentStream = await content.ReadAsStreamAsync();
+            var contentStream = await content.ReadAsStreamAsync().ConfigureAwait(false);
             var hash = CryptoUtilFactory.CryptoInstance.ComputeSHA256Hash(contentStream);
             return AWSSDKUtils.ToHex(hash, true);
         }

diff --git a/src/Private/Signer.cs b/src/Private/Signer.cs
@@ -23,7 +23,7 @@ public static async Task<Result> SignAsync(
 
             UpdateRequestUri(request, baseAddress);
 
-            var contentHash = await ContentHash.CalculateAsync(request.Content);
+            var contentHash = await ContentHash.CalculateAsync(request.Content).ConfigureAwait(false);
 
             AddHeaders(request, now, serviceName, credentials, contentHash);
 

diff --git a/src/PutAsyncExtensions.cs b/src/PutAsyncExtensions.cs
@@ -421,15 +421,17 @@ public static async Task<HttpResponseMessage> PutAsync(
         {
             if (credentials == null) throw new ArgumentNullException(nameof(credentials));
 
-            var immutableCredentials = await credentials.GetCredentialsAsync();
+            var immutableCredentials = await credentials.GetCredentialsAsync().ConfigureAwait(false);
 
-            var response = await self.PutAsync(
-                requestUri,
-                content,
-                regionName,
-                serviceName,
-                immutableCredentials,
-                cancellationToken);
+            var response = await self
+                .PutAsync(
+                    requestUri,
+                    content,
+                    regionName,
+                    serviceName,
+                    immutableCredentials,
+                    cancellationToken)
+                .ConfigureAwait(false);
 
             return response;
         }

diff --git a/src/SendAsyncExtensions.cs b/src/SendAsyncExtensions.cs
@@ -426,15 +426,17 @@ public static async Task<HttpResponseMessage> SendAsync(
         {
             if (credentials == null) throw new ArgumentNullException(nameof(credentials));
 
-            var immutableCredentials = await credentials.GetCredentialsAsync();
+            var immutableCredentials = await credentials.GetCredentialsAsync().ConfigureAwait(false);
 
-            var response = await self.SendAsync(
-                request,
-                completionOption,
-                regionName,
-                serviceName,
-                immutableCredentials,
-                cancellationToken);
+            var response = await self
+                .SendAsync(
+                    request,
+                    completionOption,
+                    regionName,
+                    serviceName,
+                    immutableCredentials,
+                    cancellationToken)
+                .ConfigureAwait(false);
 
             return response;
         }
@@ -498,16 +500,18 @@ public static async Task<HttpResponseMessage> SendAsync(
         {
             if (self == null) throw new ArgumentNullException(nameof(self));
 
-            await Signer.SignAsync(
-                request,
-                self.BaseAddress,
-                self.DefaultRequestHeaders,
-                DateTime.UtcNow,
-                regionName,
-                serviceName,
-                credentials);
+            await Signer
+                .SignAsync(
+                    request,
+                    self.BaseAddress,
+                    self.DefaultRequestHeaders,
+                    DateTime.UtcNow,
+                    regionName,
+                    serviceName,
+                    credentials)
+                .ConfigureAwait(false);
 
-            return await self.SendAsync(request, completionOption, cancellationToken);
+            return await self.SendAsync(request, completionOption, cancellationToken).ConfigureAwait(false);
         }
 
         #endregion