fix: Hotfix v4.3.1

Author: definitelynotagoblin

src/CommonLib/Helpers.cs

@@ -317,6 +317,29 @@ public static string DumpDirectoryObject(this IDirectoryObject directoryObject)
 
             return builder.ToString();
         }
+
+        /// <summary>
+        /// Attempt an action a number of times, quietly eating a specific exception until the last attempt if it throws.
+        /// </summary>
+        /// <param name="action"></param>
+        /// <param name="retryCount"></param>
+        /// <param name="logger"></param>
+        public static async Task RetryOnException<T>(Func<Task> action, int retryCount, ILogger logger = null) where T : Exception {
+            int attempt = 0;
+            bool success = false;
+            do {
+                try {
+                    await action();
+                    success = true;
+                }
+                catch (T e) {
+                    attempt++;
+                    logger?.LogDebug(e, "Exception caught, retrying attempt {Attempt}", attempt);
+                    if (attempt >= retryCount)
+                        throw;
+                }
+            } while (!success && attempt < retryCount);
+        }
     }
 
     public class ParsedGPLink {

src/CommonLib/LdapConnectionPool.cs

@@ -972,14 +972,23 @@ private LdapConnection CreateBaseConnection(string directoryIdentifier, bool ssl
                 return (false, testResult);
             }
 
-            SearchResponse response;
+            SearchResponse response = null;
             try {
                 //Do an initial search request to get the rootDSE
                 //This ldap filter is equivalent to (objectclass=*)
                 var searchRequest = CreateSearchRequest("", new LdapFilter().AddAllObjects().GetFilter(),
                     SearchScope.Base, null);
 
-                response = await SendRequestWithTimeout(connection, searchRequest, _testConnectionAdaptiveTimeout);
+                await Helpers.RetryOnException<TimeoutException>(async () => {
+                    response = await SendRequestWithTimeout(connection, searchRequest, _testConnectionAdaptiveTimeout);
+                }, retryCount: 2, logger: _log);
+            }
+            catch (TimeoutException e) {
+                /*
+                 * We've retried this connection a few times but haven't succeeded
+                 */
+                testResult.Message = e.Message;
+                return (false, testResult);
             }
             catch (LdapException e) {
                 /*

src/CommonLib/SharpHoundCommonLib.csproj

@@ -9,7 +9,7 @@
         <PackageDescription>Common library for C# BloodHound enumeration tasks</PackageDescription>
         <PackageLicenseExpression>GPL-3.0-only</PackageLicenseExpression>
         <RepositoryUrl>https://github.com/BloodHoundAD/SharpHoundCommon</RepositoryUrl>
-        <Version>4.2.8</Version>
+        <Version>4.3.1</Version>
         <AssemblyName>SharpHoundCommonLib</AssemblyName>
         <RootNamespace>SharpHoundCommonLib</RootNamespace>
     </PropertyGroup>

src/SharpHoundRPC/SharpHoundRPC.csproj

@@ -8,7 +8,7 @@
         <Company>SpecterOps</Company>
         <PackageDescription>SAM/LSA Wrapper for C# BloodHound tasks</PackageDescription>
         <PackageLicenseExpression>GPL-3.0-only</PackageLicenseExpression>
-        <Version>4.2.1</Version>
+        <Version>4.3.1</Version>
         <AssemblyName>SharpHoundRPC</AssemblyName>
         <RootNamespace>SharpHoundRPC</RootNamespace>
     </PropertyGroup>

test/unit/CommonLibHelperTests.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Text;
+using System.Threading.Tasks;
 using SharpHoundCommonLib;
 using SharpHoundCommonLib.Enums;
 using Xunit;
@@ -249,5 +250,48 @@ public void ConvertTimestampToUnixEpoch_InvalidTimestamp() {
 
             Assert.Equal(0, result);
         }
+
+        [Fact]
+        public async Task RetryOnException_ThrowsExpected() {
+            int attemptCount = 0;
+            Func<Task> throws = () => {
+                attemptCount++;
+                throw new ApplicationException();
+            };
+
+            await Assert.ThrowsAsync<ApplicationException>(() => Helpers.RetryOnException<ApplicationException>(throws, 3));
+            Assert.Equal(3, attemptCount);
+        }
+
+        [Fact]
+        public async Task RetryOnException_ThrowsUnexpected() {
+            int attemptCount = 0;
+            Func<Task> throws = () => {
+                attemptCount++;
+                throw new Exception();
+            };
+
+            await Assert.ThrowsAsync<Exception>(() => Helpers.RetryOnException<ApplicationException>(throws, 3));
+            // First try throws an Exception, but retry only happens on ApplicationException
+            Assert.Equal(1, attemptCount);
+        }
+
+        [Fact]
+        public async Task RetryOnException_SucceedsOnLastAttempt() {
+            int attemptCount = 0;
+            bool success = false;
+            Func<Task> throws = () => {
+                attemptCount++;
+                if (attemptCount < 3)
+                    throw new ApplicationException();
+
+                success = true;
+                return Task.CompletedTask;
+            };
+
+            await Helpers.RetryOnException<ApplicationException>(throws, 3);
+
+            Assert.True(success);
+        }
     }
 }