diff --git a/coverage/report/SharpHoundCommonLib_LDAPUtils.html b/coverage/report/SharpHoundCommonLib_LDAPUtils.html
index d25811e6..04b827eb 100644
--- a/coverage/report/SharpHoundCommonLib_LDAPUtils.html
+++ b/coverage/report/SharpHoundCommonLib_LDAPUtils.html
@@ -17,65 +17,66 @@
D:\a\SharpHou
| | | 18 | | using SharpHoundCommonLib.LDAPQueries; |
| | | 19 | | using SharpHoundCommonLib.OutputTypes; |
| | | 20 | | using SharpHoundCommonLib.Processors; |
-| | | 21 | | using SharpHoundRPC; |
-| | | 22 | | using SharpHoundRPC.NetAPINative; |
-| | | 23 | | using SharpHoundRPC.Wrappers; |
-| | | 24 | | using Domain = System.DirectoryServices.ActiveDirectory.Domain; |
-| | | 25 | | using SearchScope = System.DirectoryServices.Protocols.SearchScope; |
-| | | 26 | | using SecurityMasks = System.DirectoryServices.Protocols.SecurityMasks; |
-| | | 27 | | |
-| | | 28 | | namespace SharpHoundCommonLib |
-| | | 29 | | { |
-| | | 30 | | public class LDAPUtils : ILDAPUtils |
-| | | 31 | | { |
-| | | 32 | | private const string NullCacheKey = "UNIQUENULL"; |
-| | | 33 | | |
-| | | 34 | | // The following byte stream contains the necessary message to request a NetBios name from a machine |
-| | | 35 | | // http://web.archive.org/web/20100409111218/http://msdn.microsoft.com/en-us/library/system.net.sockets.socket.a |
-| | 1 | 36 | | private static readonly byte[] NameRequest = |
-| | 1 | 37 | | { |
-| | 1 | 38 | | 0x80, 0x94, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, |
-| | 1 | 39 | | 0x00, 0x00, 0x00, 0x00, 0x20, 0x43, 0x4b, 0x41, |
+| | | 21 | | using SharpHoundRPC.NetAPINative; |
+| | | 22 | | using Domain = System.DirectoryServices.ActiveDirectory.Domain; |
+| | | 23 | | using SearchScope = System.DirectoryServices.Protocols.SearchScope; |
+| | | 24 | | using SecurityMasks = System.DirectoryServices.Protocols.SecurityMasks; |
+| | | 25 | | |
+| | | 26 | | namespace SharpHoundCommonLib |
+| | | 27 | | { |
+| | | 28 | | public class LDAPUtils : ILDAPUtils |
+| | | 29 | | { |
+| | | 30 | | private const string NullCacheKey = "UNIQUENULL"; |
+| | | 31 | | |
+| | | 32 | | // The following byte stream contains the necessary message to request a NetBios name from a machine |
+| | | 33 | | // http://web.archive.org/web/20100409111218/http://msdn.microsoft.com/en-us/library/system.net.sockets.socket.a |
+| | 1 | 34 | | private static readonly byte[] NameRequest = |
+| | 1 | 35 | | { |
+| | 1 | 36 | | 0x80, 0x94, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, |
+| | 1 | 37 | | 0x00, 0x00, 0x00, 0x00, 0x20, 0x43, 0x4b, 0x41, |
+| | 1 | 38 | | 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, |
+| | 1 | 39 | | 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, |
| | 1 | 40 | | 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, |
-| | 1 | 41 | | 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, |
-| | 1 | 42 | | 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, |
-| | 1 | 43 | | 0x41, 0x41, 0x41, 0x41, 0x41, 0x00, 0x00, 0x21, |
-| | 1 | 44 | | 0x00, 0x01 |
-| | 1 | 45 | | }; |
-| | | 46 | | |
-| | | 47 | | |
-| | 1 | 48 | | private static readonly ConcurrentDictionary<string, ResolvedWellKnownPrincipal> |
-| | 1 | 49 | | SeenWellKnownPrincipals = new(); |
+| | 1 | 41 | | 0x41, 0x41, 0x41, 0x41, 0x41, 0x00, 0x00, 0x21, |
+| | 1 | 42 | | 0x00, 0x01 |
+| | 1 | 43 | | }; |
+| | | 44 | | |
+| | | 45 | | |
+| | 1 | 46 | | private static readonly ConcurrentDictionary<string, ResolvedWellKnownPrincipal> |
+| | 1 | 47 | | SeenWellKnownPrincipals = new(); |
+| | | 48 | | |
+| | 1 | 49 | | private static readonly ConcurrentDictionary<string, byte> DomainControllers = new(); |
| | | 50 | | |
-| | 1 | 51 | | private static readonly ConcurrentDictionary<string, byte> DomainControllers = new(); |
-| | | 52 | | |
-| | 64 | 53 | | private readonly ConcurrentDictionary<string, Domain> _domainCache = new(); |
-| | 64 | 54 | | private readonly ConcurrentDictionary<string, string> _domainControllerCache = new(); |
-| | 1 | 55 | | private static readonly TimeSpan MinBackoffDelay = TimeSpan.FromSeconds(2); |
-| | 1 | 56 | | private static readonly TimeSpan MaxBackoffDelay = TimeSpan.FromSeconds(10); |
-| | 1 | 57 | | private static readonly TimeSpan BackoffDelayMultiplier = TimeSpan.FromSeconds(2); |
-| | | 58 | | private const int MaxRetries = 3; |
-| | | 59 | | |
-| | 64 | 60 | | private readonly ConcurrentDictionary<string, LdapConnection> _globalCatalogConnections = new(); |
-| | 64 | 61 | | private readonly ConcurrentDictionary<string, string> _hostResolutionMap = new(); |
-| | 64 | 62 | | private readonly ConcurrentDictionary<string, LdapConnection> _ldapConnections = new(); |
-| | 64 | 63 | | private readonly ConcurrentDictionary<string, int> _ldapRangeSizeCache = new(); |
-| | | 64 | | private readonly ILogger _log; |
-| | | 65 | | private readonly NativeMethods _nativeMethods; |
-| | 64 | 66 | | private readonly ConcurrentDictionary<string, string> _netbiosCache = new(); |
-| | | 67 | | private readonly PortScanner _portScanner; |
-| | 64 | 68 | | private LDAPConfig _ldapConfig = new(); |
+| | 64 | 51 | | private readonly ConcurrentDictionary<string, Domain> _domainCache = new(); |
+| | 64 | 52 | | private readonly ConcurrentDictionary<string, string> _domainControllerCache = new(); |
+| | 1 | 53 | | private static readonly TimeSpan MinBackoffDelay = TimeSpan.FromSeconds(2); |
+| | 1 | 54 | | private static readonly TimeSpan MaxBackoffDelay = TimeSpan.FromSeconds(20); |
+| | | 55 | | private const int BackoffDelayMultiplier = 2; |
+| | | 56 | | private const int MaxRetries = 3; |
+| | | 57 | | |
+| | 64 | 58 | | private readonly ConcurrentDictionary<string, LdapConnection> _globalCatalogConnections = new(); |
+| | 64 | 59 | | private readonly ConcurrentDictionary<string, string> _hostResolutionMap = new(); |
+| | 64 | 60 | | private readonly ConcurrentDictionary<string, LdapConnection> _ldapConnections = new(); |
+| | 64 | 61 | | private readonly ConcurrentDictionary<string, int> _ldapRangeSizeCache = new(); |
+| | | 62 | | private readonly ILogger _log; |
+| | | 63 | | private readonly NativeMethods _nativeMethods; |
+| | 64 | 64 | | private readonly ConcurrentDictionary<string, string> _netbiosCache = new(); |
+| | | 65 | | private readonly PortScanner _portScanner; |
+| | 64 | 66 | | private LDAPConfig _ldapConfig = new(); |
+| | 64 | 67 | | private readonly ManualResetEvent _connectionResetEvent = new(false); |
+| | 64 | 68 | | private readonly object _lockObj = new(); |
| | | 69 | | |
-| | | 70 | | /// <summary> |
-| | | 71 | | /// Creates a new instance of LDAP Utils with defaults |
-| | | 72 | | /// </summary> |
-| | 64 | 73 | | public LDAPUtils() |
-| | 64 | 74 | | { |
-| | 64 | 75 | | _nativeMethods = new NativeMethods(); |
-| | 64 | 76 | | _portScanner = new PortScanner(); |
-| | 64 | 77 | | _log = Logging.LogProvider.CreateLogger("LDAPUtils"); |
-| | 64 | 78 | | } |
-| | | 79 | | |
-| | | 80 | | /// <summary> |
-| | | 81 | | /// Creates a new instance of LDAP utils and allows overriding implementations |
-| | | 82 | | /// </summary> |
-| | | 83 | | /// <param name="nativeMethods"></param> |
-| | | 84 | | /// <param name="scanner"></param> |
-| | | 85 | | /// <param name="log"></param> |
-| | 0 | 86 | | public LDAPUtils(NativeMethods nativeMethods = null, PortScanner scanner = null, ILogger log = null) |
-| | 0 | 87 | | { |
-| | 0 | 88 | | _nativeMethods = nativeMethods ?? new NativeMethods(); |
-| | 0 | 89 | | _portScanner = scanner ?? new PortScanner(); |
-| | 0 | 90 | | _log = log ?? Logging.LogProvider.CreateLogger("LDAPUtils"); |
-| | 0 | 91 | | } |
-| | | 92 | | |
-| | | 93 | | /// <summary> |
-| | | 94 | | /// Sets the configuration for LDAP queries |
-| | | 95 | | /// </summary> |
-| | | 96 | | /// <param name="config"></param> |
-| | | 97 | | /// <exception cref="Exception"></exception> |
-| | | 98 | | public void SetLDAPConfig(LDAPConfig config) |
-| | 0 | 99 | | { |
-| | 0 | 100 | | _ldapConfig = config ?? throw new Exception("LDAP Configuration can not be null"); |
-| | 0 | 101 | | _domainControllerCache.Clear(); |
-| | 0 | 102 | | foreach (var kv in _globalCatalogConnections) |
-| | 0 | 103 | | { |
-| | 0 | 104 | | kv.Value.Dispose(); |
-| | 0 | 105 | | } |
-| | 0 | 106 | | _globalCatalogConnections.Clear(); |
-| | 0 | 107 | | foreach (var kv in _ldapConnections) |
-| | 0 | 108 | | { |
-| | 0 | 109 | | kv.Value.Dispose(); |
-| | 0 | 110 | | } |
-| | 0 | 111 | | _ldapConnections.Clear(); |
-| | 0 | 112 | | } |
+| | | 70 | | |
+| | | 71 | | /// <summary> |
+| | | 72 | | /// Creates a new instance of LDAP Utils with defaults |
+| | | 73 | | /// </summary> |
+| | 64 | 74 | | public LDAPUtils() |
+| | 64 | 75 | | { |
+| | 64 | 76 | | _nativeMethods = new NativeMethods(); |
+| | 64 | 77 | | _portScanner = new PortScanner(); |
+| | 64 | 78 | | _log = Logging.LogProvider.CreateLogger("LDAPUtils"); |
+| | 64 | 79 | | } |
+| | | 80 | | |
+| | | 81 | | /// <summary> |
+| | | 82 | | /// Creates a new instance of LDAP utils and allows overriding implementations |
+| | | 83 | | /// </summary> |
+| | | 84 | | /// <param name="nativeMethods"></param> |
+| | | 85 | | /// <param name="scanner"></param> |
+| | | 86 | | /// <param name="log"></param> |
+| | 0 | 87 | | public LDAPUtils(NativeMethods nativeMethods = null, PortScanner scanner = null, ILogger log = null) |
+| | 0 | 88 | | { |
+| | 0 | 89 | | _nativeMethods = nativeMethods ?? new NativeMethods(); |
+| | 0 | 90 | | _portScanner = scanner ?? new PortScanner(); |
+| | 0 | 91 | | _log = log ?? Logging.LogProvider.CreateLogger("LDAPUtils"); |
+| | 0 | 92 | | } |
+| | | 93 | | |
+| | | 94 | | /// <summary> |
+| | | 95 | | /// Sets the configuration for LDAP queries |
+| | | 96 | | /// </summary> |
+| | | 97 | | /// <param name="config"></param> |
+| | | 98 | | /// <exception cref="Exception"></exception> |
+| | | 99 | | public void SetLDAPConfig(LDAPConfig config) |
+| | 0 | 100 | | { |
+| | 0 | 101 | | _ldapConfig = config ?? throw new Exception("LDAP Configuration can not be null"); |
+| | 0 | 102 | | _domainControllerCache.Clear(); |
+| | 0 | 103 | | foreach (var kv in _globalCatalogConnections) |
+| | 0 | 104 | | { |
+| | 0 | 105 | | kv.Value.Dispose(); |
+| | 0 | 106 | | } |
+| | | 107 | | |
+| | 0 | 108 | | _globalCatalogConnections.Clear(); |
+| | 0 | 109 | | foreach (var kv in _ldapConnections) |
+| | 0 | 110 | | { |
+| | 0 | 111 | | kv.Value.Dispose(); |
+| | 0 | 112 | | } |
| | | 113 | | |
-| | | 114 | | /// <summary> |
-| | | 115 | | /// Turns a sid into a well known principal ID. |
-| | | 116 | | /// </summary> |
-| | | 117 | | /// <param name="sid"></param> |
-| | | 118 | | /// <param name="domain"></param> |
-| | | 119 | | /// <param name="commonPrincipal"></param> |
-| | | 120 | | /// <returns>True if a well known principal was identified, false if not</returns> |
-| | | 121 | | public bool GetWellKnownPrincipal(string sid, string domain, out TypedPrincipal commonPrincipal) |
-| | 4 | 122 | | { |
-| | 5 | 123 | | if (!WellKnownPrincipal.GetWellKnownPrincipal(sid, out commonPrincipal)) return false; |
-| | 3 | 124 | | var tempDomain = domain ?? GetDomain()?.Name ?? "UNKNOWN"; |
-| | 3 | 125 | | commonPrincipal.ObjectIdentifier = ConvertWellKnownPrincipal(sid, tempDomain); |
-| | 3 | 126 | | SeenWellKnownPrincipals.TryAdd(commonPrincipal.ObjectIdentifier, new ResolvedWellKnownPrincipal |
-| | 3 | 127 | | { |
-| | 3 | 128 | | DomainName = domain, |
-| | 3 | 129 | | WkpId = sid |
-| | 3 | 130 | | }); |
-| | 3 | 131 | | return true; |
-| | 4 | 132 | | } |
-| | | 133 | | |
-| | | 134 | | /// <summary> |
-| | | 135 | | /// Adds a SID to an internal list of domain controllers |
-| | | 136 | | /// </summary> |
-| | | 137 | | /// <param name="domainControllerSID"></param> |
-| | | 138 | | public void AddDomainController(string domainControllerSID) |
-| | 0 | 139 | | { |
-| | 0 | 140 | | DomainControllers.TryAdd(domainControllerSID, new byte()); |
-| | 0 | 141 | | } |
-| | | 142 | | |
-| | | 143 | | /// <summary> |
-| | | 144 | | /// Gets output objects for currently observed well known principals |
-| | | 145 | | /// </summary> |
-| | | 146 | | /// <returns></returns> |
-| | | 147 | | /// <exception cref="ArgumentOutOfRangeException"></exception> |
-| | | 148 | | public IEnumerable<OutputBase> GetWellKnownPrincipalOutput(string domain) |
-| | 0 | 149 | | { |
-| | 0 | 150 | | foreach (var wkp in SeenWellKnownPrincipals) |
-| | 0 | 151 | | { |
-| | 0 | 152 | | WellKnownPrincipal.GetWellKnownPrincipal(wkp.Value.WkpId, out var principal); |
-| | 0 | 153 | | OutputBase output = principal.ObjectType switch |
-| | 0 | 154 | | { |
-| | 0 | 155 | | Label.User => new User(), |
-| | 0 | 156 | | Label.Computer => new Computer(), |
-| | 0 | 157 | | Label.Group => new Group(), |
-| | 0 | 158 | | Label.GPO => new GPO(), |
-| | 0 | 159 | | Label.Domain => new OutputTypes.Domain(), |
-| | 0 | 160 | | Label.OU => new OU(), |
-| | 0 | 161 | | Label.Container => new Container(), |
-| | 0 | 162 | | Label.Configuration => new Container(), |
-| | 0 | 163 | | _ => throw new ArgumentOutOfRangeException() |
-| | 0 | 164 | | }; |
-| | | 165 | | |
-| | 0 | 166 | | output.Properties.Add("name", $"{principal.ObjectIdentifier}@{wkp.Value.DomainName}".ToUpper()); |
-| | 0 | 167 | | var domainSid = GetSidFromDomainName(wkp.Value.DomainName); |
-| | 0 | 168 | | output.Properties.Add("domainsid", domainSid); |
-| | 0 | 169 | | output.Properties.Add("domain", wkp.Value.DomainName.ToUpper()); |
-| | 0 | 170 | | output.ObjectIdentifier = wkp.Key; |
-| | 0 | 171 | | yield return output; |
-| | 0 | 172 | | } |
-| | | 173 | | |
-| | 0 | 174 | | var entdc = GetBaseEnterpriseDC(domain); |
-| | 0 | 175 | | entdc.Members = DomainControllers.Select(x => new TypedPrincipal(x.Key, Label.Computer)).ToArray(); |
-| | 0 | 176 | | yield return entdc; |
-| | 0 | 177 | | } |
-| | | 178 | | |
-| | | 179 | | /// <summary> |
-| | | 180 | | /// Converts a |
-| | | 181 | | /// </summary> |
-| | | 182 | | /// <param name="sid"></param> |
-| | | 183 | | /// <param name="domain"></param> |
-| | | 184 | | /// <returns></returns> |
-| | | 185 | | public string ConvertWellKnownPrincipal(string sid, string domain) |
-| | 3 | 186 | | { |
-| | 3 | 187 | | if (!WellKnownPrincipal.GetWellKnownPrincipal(sid, out _)) return sid; |
-| | | 188 | | |
-| | 5 | 189 | | if (sid != "S-1-5-9") return $"{domain}-{sid}".ToUpper(); |
-| | | 190 | | |
-| | 1 | 191 | | var forest = GetForest(domain)?.Name; |
-| | 1 | 192 | | if (forest == null) _log.LogWarning("Error getting forest, ENTDC sid is likely incorrect"); |
-| | 1 | 193 | | return $"{forest ?? "UNKNOWN"}-{sid}".ToUpper(); |
-| | 3 | 194 | | } |
-| | | 195 | | |
-| | | 196 | | /// <summary> |
-| | | 197 | | /// Queries the global catalog to get potential SID matches for a username in the forest |
-| | | 198 | | /// </summary> |
-| | | 199 | | /// <param name="name"></param> |
-| | | 200 | | /// <returns></returns> |
-| | | 201 | | public string[] GetUserGlobalCatalogMatches(string name) |
-| | 1 | 202 | | { |
-| | 1 | 203 | | var tempName = name.ToLower(); |
-| | 1 | 204 | | if (Cache.GetGCCache(tempName, out var sids)) |
-| | 0 | 205 | | return sids; |
-| | | 206 | | |
-| | 1 | 207 | | var query = new LDAPFilter().AddUsers($"samaccountname={tempName}").GetFilter(); |
-| | 1 | 208 | | var results = QueryLDAP(query, SearchScope.Subtree, new[] { "objectsid" }, globalCatalog: true) |
-| | 1 | 209 | | .Select(x => x.GetSid()).Where(x => x != null).ToArray(); |
-| | 1 | 210 | | Cache.AddGCCache(tempName, results); |
-| | 1 | 211 | | return results; |
-| | 1 | 212 | | } |
-| | | 213 | | |
-| | | 214 | | /// <summary> |
-| | | 215 | | /// Uses an LDAP lookup to attempt to find the Label for a given SID |
-| | | 216 | | /// Will also convert to a well known principal ID if needed |
-| | | 217 | | /// </summary> |
-| | | 218 | | /// <param name="id"></param> |
-| | | 219 | | /// <param name="fallbackDomain"></param> |
-| | | 220 | | /// <returns></returns> |
-| | | 221 | | public TypedPrincipal ResolveIDAndType(string id, string fallbackDomain) |
-| | 2 | 222 | | { |
-| | | 223 | | //This is a duplicated SID object which is weird and makes things unhappy. Throw it out |
-| | 2 | 224 | | if (id.Contains("0ACNF")) |
-| | 1 | 225 | | return null; |
-| | | 226 | | |
-| | 1 | 227 | | if (GetWellKnownPrincipal(id, fallbackDomain, out var principal)) |
-| | 1 | 228 | | return principal; |
+| | 0 | 114 | | _ldapConnections.Clear(); |
+| | 0 | 115 | | } |
+| | | 116 | | |
+| | | 117 | | /// <summary> |
+| | | 118 | | /// Turns a sid into a well known principal ID. |
+| | | 119 | | /// </summary> |
+| | | 120 | | /// <param name="sid"></param> |
+| | | 121 | | /// <param name="domain"></param> |
+| | | 122 | | /// <param name="commonPrincipal"></param> |
+| | | 123 | | /// <returns>True if a well known principal was identified, false if not</returns> |
+| | | 124 | | public bool GetWellKnownPrincipal(string sid, string domain, out TypedPrincipal commonPrincipal) |
+| | 4 | 125 | | { |
+| | 5 | 126 | | if (!WellKnownPrincipal.GetWellKnownPrincipal(sid, out commonPrincipal)) return false; |
+| | 3 | 127 | | var tempDomain = domain ?? GetDomain()?.Name ?? "UNKNOWN"; |
+| | 3 | 128 | | commonPrincipal.ObjectIdentifier = ConvertWellKnownPrincipal(sid, tempDomain); |
+| | 3 | 129 | | SeenWellKnownPrincipals.TryAdd(commonPrincipal.ObjectIdentifier, new ResolvedWellKnownPrincipal |
+| | 3 | 130 | | { |
+| | 3 | 131 | | DomainName = domain, |
+| | 3 | 132 | | WkpId = sid |
+| | 3 | 133 | | }); |
+| | 3 | 134 | | return true; |
+| | 4 | 135 | | } |
+| | | 136 | | |
+| | | 137 | | /// <summary> |
+| | | 138 | | /// Adds a SID to an internal list of domain controllers |
+| | | 139 | | /// </summary> |
+| | | 140 | | /// <param name="domainControllerSID"></param> |
+| | | 141 | | public void AddDomainController(string domainControllerSID) |
+| | 0 | 142 | | { |
+| | 0 | 143 | | DomainControllers.TryAdd(domainControllerSID, new byte()); |
+| | 0 | 144 | | } |
+| | | 145 | | |
+| | | 146 | | /// <summary> |
+| | | 147 | | /// Gets output objects for currently observed well known principals |
+| | | 148 | | /// </summary> |
+| | | 149 | | /// <returns></returns> |
+| | | 150 | | /// <exception cref="ArgumentOutOfRangeException"></exception> |
+| | | 151 | | public IEnumerable<OutputBase> GetWellKnownPrincipalOutput(string domain) |
+| | 0 | 152 | | { |
+| | 0 | 153 | | foreach (var wkp in SeenWellKnownPrincipals) |
+| | 0 | 154 | | { |
+| | 0 | 155 | | WellKnownPrincipal.GetWellKnownPrincipal(wkp.Value.WkpId, out var principal); |
+| | 0 | 156 | | OutputBase output = principal.ObjectType switch |
+| | 0 | 157 | | { |
+| | 0 | 158 | | Label.User => new User(), |
+| | 0 | 159 | | Label.Computer => new Computer(), |
+| | 0 | 160 | | Label.Group => new Group(), |
+| | 0 | 161 | | Label.GPO => new GPO(), |
+| | 0 | 162 | | Label.Domain => new OutputTypes.Domain(), |
+| | 0 | 163 | | Label.OU => new OU(), |
+| | 0 | 164 | | Label.Container => new Container(), |
+| | 0 | 165 | | Label.Configuration => new Container(), |
+| | 0 | 166 | | _ => throw new ArgumentOutOfRangeException() |
+| | 0 | 167 | | }; |
+| | | 168 | | |
+| | 0 | 169 | | output.Properties.Add("name", $"{principal.ObjectIdentifier}@{wkp.Value.DomainName}".ToUpper()); |
+| | 0 | 170 | | var domainSid = GetSidFromDomainName(wkp.Value.DomainName); |
+| | 0 | 171 | | output.Properties.Add("domainsid", domainSid); |
+| | 0 | 172 | | output.Properties.Add("domain", wkp.Value.DomainName.ToUpper()); |
+| | 0 | 173 | | output.ObjectIdentifier = wkp.Key; |
+| | 0 | 174 | | yield return output; |
+| | 0 | 175 | | } |
+| | | 176 | | |
+| | 0 | 177 | | var entdc = GetBaseEnterpriseDC(domain); |
+| | 0 | 178 | | entdc.Members = DomainControllers.Select(x => new TypedPrincipal(x.Key, Label.Computer)).ToArray(); |
+| | 0 | 179 | | yield return entdc; |
+| | 0 | 180 | | } |
+| | | 181 | | |
+| | | 182 | | /// <summary> |
+| | | 183 | | /// Converts a |
+| | | 184 | | /// </summary> |
+| | | 185 | | /// <param name="sid"></param> |
+| | | 186 | | /// <param name="domain"></param> |
+| | | 187 | | /// <returns></returns> |
+| | | 188 | | public string ConvertWellKnownPrincipal(string sid, string domain) |
+| | 3 | 189 | | { |
+| | 3 | 190 | | if (!WellKnownPrincipal.GetWellKnownPrincipal(sid, out _)) return sid; |
+| | | 191 | | |
+| | 5 | 192 | | if (sid != "S-1-5-9") return $"{domain}-{sid}".ToUpper(); |
+| | | 193 | | |
+| | 1 | 194 | | var forest = GetForest(domain)?.Name; |
+| | 1 | 195 | | if (forest == null) _log.LogWarning("Error getting forest, ENTDC sid is likely incorrect"); |
+| | 1 | 196 | | return $"{forest ?? "UNKNOWN"}-{sid}".ToUpper(); |
+| | 3 | 197 | | } |
+| | | 198 | | |
+| | | 199 | | /// <summary> |
+| | | 200 | | /// Queries the global catalog to get potential SID matches for a username in the forest |
+| | | 201 | | /// </summary> |
+| | | 202 | | /// <param name="name"></param> |
+| | | 203 | | /// <returns></returns> |
+| | | 204 | | public string[] GetUserGlobalCatalogMatches(string name) |
+| | 1 | 205 | | { |
+| | 1 | 206 | | var tempName = name.ToLower(); |
+| | 1 | 207 | | if (Cache.GetGCCache(tempName, out var sids)) |
+| | 0 | 208 | | return sids; |
+| | | 209 | | |
+| | 1 | 210 | | var query = new LDAPFilter().AddUsers($"samaccountname={tempName}").GetFilter(); |
+| | 1 | 211 | | var results = QueryLDAP(query, SearchScope.Subtree, new[] { "objectsid" }, globalCatalog: true) |
+| | 1 | 212 | | .Select(x => x.GetSid()).Where(x => x != null).ToArray(); |
+| | 1 | 213 | | Cache.AddGCCache(tempName, results); |
+| | 1 | 214 | | return results; |
+| | 1 | 215 | | } |
+| | | 216 | | |
+| | | 217 | | /// <summary> |
+| | | 218 | | /// Uses an LDAP lookup to attempt to find the Label for a given SID |
+| | | 219 | | /// Will also convert to a well known principal ID if needed |
+| | | 220 | | /// </summary> |
+| | | 221 | | /// <param name="id"></param> |
+| | | 222 | | /// <param name="fallbackDomain"></param> |
+| | | 223 | | /// <returns></returns> |
+| | | 224 | | public TypedPrincipal ResolveIDAndType(string id, string fallbackDomain) |
+| | 2 | 225 | | { |
+| | | 226 | | //This is a duplicated SID object which is weird and makes things unhappy. Throw it out |
+| | 2 | 227 | | if (id.Contains("0ACNF")) |
+| | 1 | 228 | | return null; |
| | | 229 | | |
-| | 0 | 230 | | var type = id.StartsWith("S-") ? LookupSidType(id, fallbackDomain) : LookupGuidType(id, fallbackDomain); |
-| | 0 | 231 | | return new TypedPrincipal(id, type); |
-| | 2 | 232 | | } |
-| | | 233 | | |
-| | | 234 | | public TypedPrincipal ResolveCertTemplateByProperty(string propValue, string propertyName, string containerDN, s |
-| | 0 | 235 | | { |
-| | 0 | 236 | | var filter = new LDAPFilter().AddCertificateTemplates().AddFilter(propertyName + "=" + propValue, true); |
-| | 0 | 237 | | var res = QueryLDAP(filter.GetFilter(), SearchScope.OneLevel, |
-| | 0 | 238 | | CommonProperties.TypeResolutionProps, adsPath: containerDN, domainName: domainName); |
-| | | 239 | | |
-| | 0 | 240 | | if (res == null) |
-| | 0 | 241 | | { |
-| | 0 | 242 | | _log.LogWarning("Could not find certificate template with '{propertyName}:{propValue}' under {containerD |
-| | 0 | 243 | | return null; |
-| | | 244 | | } |
-| | | 245 | | |
-| | 0 | 246 | | List<ISearchResultEntry> resList = new List<ISearchResultEntry>(res); |
-| | 0 | 247 | | if (resList.Count == 0) |
-| | 0 | 248 | | { |
-| | 0 | 249 | | _log.LogWarning("Could not find certificate template with '{propertyName}:{propValue}' under {containerD |
-| | 0 | 250 | | return null; |
-| | | 251 | | } |
-| | | 252 | | |
-| | 0 | 253 | | if (resList.Count > 1) |
+| | 1 | 230 | | if (GetWellKnownPrincipal(id, fallbackDomain, out var principal)) |
+| | 1 | 231 | | return principal; |
+| | | 232 | | |
+| | 0 | 233 | | var type = id.StartsWith("S-") ? LookupSidType(id, fallbackDomain) : LookupGuidType(id, fallbackDomain); |
+| | 0 | 234 | | return new TypedPrincipal(id, type); |
+| | 2 | 235 | | } |
+| | | 236 | | |
+| | | 237 | | public TypedPrincipal ResolveCertTemplateByProperty(string propValue, string propertyName, string containerDN, |
+| | | 238 | | string domainName) |
+| | 0 | 239 | | { |
+| | 0 | 240 | | var filter = new LDAPFilter().AddCertificateTemplates().AddFilter(propertyName + "=" + propValue, true); |
+| | 0 | 241 | | var res = QueryLDAP(filter.GetFilter(), SearchScope.OneLevel, |
+| | 0 | 242 | | CommonProperties.TypeResolutionProps, adsPath: containerDN, domainName: domainName); |
+| | | 243 | | |
+| | 0 | 244 | | if (res == null) |
+| | 0 | 245 | | { |
+| | 0 | 246 | | _log.LogWarning( |
+| | 0 | 247 | | "Could not find certificate template with '{propertyName}:{propValue}' under {containerDN}; null res |
+| | 0 | 248 | | propertyName, propValue, containerDN); |
+| | 0 | 249 | | return null; |
+| | | 250 | | } |
+| | | 251 | | |
+| | 0 | 252 | | List<ISearchResultEntry> resList = new List<ISearchResultEntry>(res); |
+| | 0 | 253 | | if (resList.Count == 0) |
| | 0 | 254 | | { |
-| | 0 | 255 | | _log.LogWarning("Found more than one certificate template with '{propertyName}:{propValue}' under {conta |
-| | 0 | 256 | | return null; |
-| | | 257 | | } |
-| | | 258 | | |
-| | 0 | 259 | | ISearchResultEntry searchResultEntry = resList.FirstOrDefault(); |
-| | 0 | 260 | | return new TypedPrincipal(searchResultEntry.GetGuid(), Label.CertTemplate); |
-| | 0 | 261 | | } |
-| | | 262 | | |
-| | | 263 | | /// <summary> |
-| | | 264 | | /// Attempts to lookup the Label for a sid |
-| | | 265 | | /// </summary> |
-| | | 266 | | /// <param name="sid"></param> |
-| | | 267 | | /// <param name="domain"></param> |
-| | | 268 | | /// <returns></returns> |
-| | | 269 | | public Label LookupSidType(string sid, string domain) |
-| | 0 | 270 | | { |
-| | 0 | 271 | | if (Cache.GetIDType(sid, out var type)) |
-| | 0 | 272 | | return type; |
-| | | 273 | | |
-| | 0 | 274 | | var rDomain = GetDomainNameFromSid(sid) ?? domain; |
-| | | 275 | | |
-| | 0 | 276 | | var result = |
-| | 0 | 277 | | QueryLDAP(CommonFilters.SpecificSID(sid), SearchScope.Subtree, CommonProperties.TypeResolutionProps, |
-| | 0 | 278 | | rDomain) |
-| | 0 | 279 | | .DefaultIfEmpty(null).FirstOrDefault(); |
-| | | 280 | | |
-| | 0 | 281 | | type = result?.GetLabel() ?? Label.Base; |
-| | 0 | 282 | | Cache.AddType(sid, type); |
-| | 0 | 283 | | return type; |
-| | 0 | 284 | | } |
+| | 0 | 255 | | _log.LogWarning( |
+| | 0 | 256 | | "Could not find certificate template with '{propertyName}:{propValue}' under {containerDN}; empty li |
+| | 0 | 257 | | propertyName, propValue, containerDN); |
+| | 0 | 258 | | return null; |
+| | | 259 | | } |
+| | | 260 | | |
+| | 0 | 261 | | if (resList.Count > 1) |
+| | 0 | 262 | | { |
+| | 0 | 263 | | _log.LogWarning( |
+| | 0 | 264 | | "Found more than one certificate template with '{propertyName}:{propValue}' under {containerDN}", |
+| | 0 | 265 | | propertyName, propValue, containerDN); |
+| | 0 | 266 | | return null; |
+| | | 267 | | } |
+| | | 268 | | |
+| | 0 | 269 | | ISearchResultEntry searchResultEntry = resList.FirstOrDefault(); |
+| | 0 | 270 | | return new TypedPrincipal(searchResultEntry.GetGuid(), Label.CertTemplate); |
+| | 0 | 271 | | } |
+| | | 272 | | |
+| | | 273 | | /// <summary> |
+| | | 274 | | /// Attempts to lookup the Label for a sid |
+| | | 275 | | /// </summary> |
+| | | 276 | | /// <param name="sid"></param> |
+| | | 277 | | /// <param name="domain"></param> |
+| | | 278 | | /// <returns></returns> |
+| | | 279 | | public Label LookupSidType(string sid, string domain) |
+| | 0 | 280 | | { |
+| | 0 | 281 | | if (Cache.GetIDType(sid, out var type)) |
+| | 0 | 282 | | return type; |
+| | | 283 | | |
+| | 0 | 284 | | var rDomain = GetDomainNameFromSid(sid) ?? domain; |
| | | 285 | | |
-| | | 286 | | /// <summary> |
-| | | 287 | | /// Attempts to lookup the Label for a GUID |
-| | | 288 | | /// </summary> |
-| | | 289 | | /// <param name="guid"></param> |
-| | | 290 | | /// <param name="domain"></param> |
-| | | 291 | | /// <returns></returns> |
-| | | 292 | | public Label LookupGuidType(string guid, string domain) |
-| | 0 | 293 | | { |
-| | 0 | 294 | | if (Cache.GetIDType(guid, out var type)) |
-| | 0 | 295 | | return type; |
-| | | 296 | | |
-| | 0 | 297 | | var hex = Helpers.ConvertGuidToHexGuid(guid); |
-| | 0 | 298 | | if (hex == null) |
-| | 0 | 299 | | return Label.Base; |
-| | | 300 | | |
-| | 0 | 301 | | var result = |
-| | 0 | 302 | | QueryLDAP($"(objectguid={hex})", SearchScope.Subtree, CommonProperties.TypeResolutionProps, domain) |
-| | 0 | 303 | | .DefaultIfEmpty(null).FirstOrDefault(); |
-| | | 304 | | |
-| | 0 | 305 | | type = result?.GetLabel() ?? Label.Base; |
-| | 0 | 306 | | Cache.AddType(guid, type); |
-| | 0 | 307 | | return type; |
-| | 0 | 308 | | } |
-| | | 309 | | |
-| | | 310 | | /// <summary> |
-| | | 311 | | /// Attempts to find the domain associated with a SID |
-| | | 312 | | /// </summary> |
-| | | 313 | | /// <param name="sid"></param> |
-| | | 314 | | /// <returns></returns> |
-| | | 315 | | public string GetDomainNameFromSid(string sid) |
-| | 0 | 316 | | { |
-| | | 317 | | try |
-| | 0 | 318 | | { |
-| | 0 | 319 | | var parsedSid = new SecurityIdentifier(sid); |
-| | 0 | 320 | | var domainSid = parsedSid.AccountDomainSid?.Value.ToUpper(); |
-| | 0 | 321 | | if (domainSid == null) |
-| | 0 | 322 | | return null; |
-| | | 323 | | |
-| | 0 | 324 | | _log.LogDebug("Resolving sid {DomainSid}", domainSid); |
-| | | 325 | | |
-| | 0 | 326 | | if (Cache.GetDomainSidMapping(domainSid, out var domain)) |
-| | 0 | 327 | | return domain; |
-| | | 328 | | |
-| | 0 | 329 | | _log.LogDebug("No cache hit for {DomainSid}", domainSid); |
-| | 0 | 330 | | domain = GetDomainNameFromSidLdap(domainSid); |
-| | 0 | 331 | | _log.LogDebug("Resolved to {Domain}", domain); |
-| | | 332 | | |
-| | | 333 | | //Cache both to and from so we can use this later |
-| | 0 | 334 | | if (domain != null) |
-| | 0 | 335 | | { |
-| | 0 | 336 | | Cache.AddSidToDomain(domainSid, domain); |
-| | 0 | 337 | | Cache.AddSidToDomain(domain, domainSid); |
-| | 0 | 338 | | } |
-| | | 339 | | |
-| | 0 | 340 | | return domain; |
-| | | 341 | | } |
-| | 0 | 342 | | catch |
-| | 0 | 343 | | { |
-| | 0 | 344 | | return null; |
-| | | 345 | | } |
-| | 0 | 346 | | } |
-| | | 347 | | |
-| | | 348 | | /// <summary> |
-| | | 349 | | /// Attempts to get the SID associated with a domain name |
-| | | 350 | | /// </summary> |
-| | | 351 | | /// <param name="domainName"></param> |
-| | | 352 | | /// <returns></returns> |
-| | | 353 | | public string GetSidFromDomainName(string domainName) |
-| | 0 | 354 | | { |
-| | 0 | 355 | | var tempDomainName = NormalizeDomainName(domainName); |
-| | 0 | 356 | | if (tempDomainName == null) |
-| | 0 | 357 | | return null; |
-| | 0 | 358 | | if (Cache.GetDomainSidMapping(tempDomainName, out var sid)) return sid; |
-| | | 359 | | |
-| | 0 | 360 | | var domainObj = GetDomain(tempDomainName); |
-| | | 361 | | |
-| | 0 | 362 | | if (domainObj != null) |
-| | 0 | 363 | | sid = domainObj.GetDirectoryEntry().GetSid(); |
-| | | 364 | | else |
-| | 0 | 365 | | sid = null; |
-| | | 366 | | |
-| | 0 | 367 | | if (sid != null) |
-| | 0 | 368 | | { |
-| | 0 | 369 | | Cache.AddSidToDomain(sid, tempDomainName); |
-| | 0 | 370 | | Cache.AddSidToDomain(tempDomainName, sid); |
-| | 0 | 371 | | } |
-| | | 372 | | |
-| | 0 | 373 | | return sid; |
-| | 0 | 374 | | } |
-| | | 375 | | |
-| | | 376 | | // Saving this code for an eventual async implementation |
-| | | 377 | | // public async IAsyncEnumerable<string> DoRangedRetrievalAsync(string distinguishedName, string attributeName) |
-| | | 378 | | // { |
-| | | 379 | | // var domainName = Helpers.DistinguishedNameToDomain(distinguishedName); |
-| | | 380 | | // LdapConnection conn; |
-| | | 381 | | // try |
-| | | 382 | | // { |
-| | | 383 | | // conn = await CreateLDAPConnection(domainName, authType: _ldapConfig.AuthType); |
-| | | 384 | | // } |
-| | | 385 | | // catch |
-| | | 386 | | // { |
-| | | 387 | | // yield break; |
-| | | 388 | | // } |
-| | | 389 | | // |
-| | | 390 | | // if (conn == null) |
-| | | 391 | | // yield break; |
-| | | 392 | | // |
-| | | 393 | | // var index = 0; |
-| | | 394 | | // var step = 0; |
-| | | 395 | | // var currentRange = $"{attributeName};range={index}-*"; |
-| | | 396 | | // var complete = false; |
-| | | 397 | | // |
-| | | 398 | | // var searchRequest = CreateSearchRequest($"{attributeName}=*", SearchScope.Base, new[] {currentRange}, |
-| | | 399 | | // domainName, distinguishedName); |
-| | | 400 | | // |
-| | | 401 | | // var backoffDelay = MinBackoffDelay; |
-| | | 402 | | // var retryCount = 0; |
-| | | 403 | | // |
-| | | 404 | | // while (true) |
-| | | 405 | | // { |
-| | | 406 | | // DirectoryResponse searchResult; |
-| | | 407 | | // try |
-| | | 408 | | // { |
-| | | 409 | | // searchResult = await Task.Factory.FromAsync(conn.BeginSendRequest, conn.EndSendRequest, |
-| | | 410 | | // searchRequest, |
-| | | 411 | | // PartialResultProcessing.NoPartialResultSupport, null); |
-| | | 412 | | // } |
-| | | 413 | | // catch (LdapException le) when (le.ErrorCode == 51 && retryCount < MaxRetries) |
-| | | 414 | | // { |
-| | | 415 | | // //Allow three retries with a backoff on each one if we get a "Server is Busy" error |
-| | | 416 | | // retryCount++; |
-| | | 417 | | // await Task.Delay(backoffDelay); |
-| | | 418 | | // backoffDelay = TimeSpan.FromSeconds(Math.Min( |
-| | | 419 | | // backoffDelay.TotalSeconds * BackoffDelayMultiplier.TotalSeconds, MaxBackoffDelay.TotalSeconds |
-| | | 420 | | // continue; |
-| | | 421 | | // } |
-| | | 422 | | // catch (Exception e) |
-| | | 423 | | // { |
-| | | 424 | | // _log.LogWarning(e,"Caught exception during ranged retrieval for {DN}", distinguishedName); |
-| | | 425 | | // yield break; |
-| | | 426 | | // } |
-| | | 427 | | // |
-| | | 428 | | // if (searchResult is SearchResponse response && response.Entries.Count == 1) |
-| | | 429 | | // { |
-| | | 430 | | // var entry = response.Entries[0]; |
-| | | 431 | | // var attributeNames = entry?.Attributes?.AttributeNames; |
-| | | 432 | | // if (attributeNames != null) |
-| | | 433 | | // { |
-| | | 434 | | // foreach (string attr in attributeNames) |
-| | | 435 | | // { |
-| | | 436 | | // //Set our current range to the name of the attribute, which will tell us how far we are i |
-| | | 437 | | // currentRange = attr; |
-| | | 438 | | // //Check if the string has the * character in it. If it does, we've reached the end of thi |
-| | | 439 | | // complete = currentRange.IndexOf("*", 0, StringComparison.Ordinal) > 0; |
-| | | 440 | | // //Set our step to the number of attributes that came back. |
-| | | 441 | | // step = entry.Attributes[currentRange].Count; |
-| | | 442 | | // } |
-| | | 443 | | // } |
-| | | 444 | | // |
-| | | 445 | | // |
-| | | 446 | | // foreach (string val in entry.Attributes[currentRange].GetValues(typeof(string))) |
-| | | 447 | | // { |
-| | | 448 | | // yield return val; |
-| | | 449 | | // index++; |
-| | | 450 | | // } |
-| | | 451 | | // |
-| | | 452 | | // if (complete) yield break; |
-| | | 453 | | // |
-| | | 454 | | // currentRange = $"{attributeName};range={index}-{index + step}"; |
-| | | 455 | | // searchRequest.Attributes.Clear(); |
-| | | 456 | | // searchRequest.Attributes.Add(currentRange); |
-| | | 457 | | // } |
-| | | 458 | | // else |
-| | | 459 | | // { |
-| | | 460 | | // yield break; |
-| | | 461 | | // } |
-| | | 462 | | // } |
-| | | 463 | | // } |
-| | | 464 | | |
-| | | 465 | | /// <summary> |
-| | | 466 | | /// Performs Attribute Ranged Retrieval |
-| | | 467 | | /// https://docs.microsoft.com/en-us/windows/win32/adsi/attribute-range-retrieval |
-| | | 468 | | /// The function self-determines the range and internally handles the maximum step allowed by the server |
-| | | 469 | | /// </summary> |
-| | | 470 | | /// <param name="distinguishedName"></param> |
-| | | 471 | | /// <param name="attributeName"></param> |
-| | | 472 | | /// <returns></returns> |
-| | | 473 | | public IEnumerable<string> DoRangedRetrieval(string distinguishedName, string attributeName) |
-| | 0 | 474 | | { |
-| | 0 | 475 | | var domainName = Helpers.DistinguishedNameToDomain(distinguishedName); |
-| | 0 | 476 | | var task = Task.Run(() => CreateLDAPConnection(domainName, authType: _ldapConfig.AuthType)); |
-| | | 477 | | |
-| | | 478 | | LdapConnection conn; |
-| | | 479 | | |
-| | | 480 | | try |
-| | 0 | 481 | | { |
-| | 0 | 482 | | conn = task.ConfigureAwait(false).GetAwaiter().GetResult(); |
-| | 0 | 483 | | } |
-| | 0 | 484 | | catch |
-| | 0 | 485 | | { |
-| | 0 | 486 | | yield break; |
-| | | 487 | | } |
-| | | 488 | | |
-| | 0 | 489 | | if (conn == null) |
-| | 0 | 490 | | yield break; |
-| | | 491 | | |
-| | 0 | 492 | | var index = 0; |
-| | 0 | 493 | | var step = 0; |
-| | 0 | 494 | | var baseString = $"{attributeName}"; |
-| | | 495 | | //Example search string: member;range=0-1000 |
-| | 0 | 496 | | var currentRange = $"{baseString};range={index}-*"; |
-| | 0 | 497 | | var complete = false; |
+| | 0 | 286 | | var result = |
+| | 0 | 287 | | QueryLDAP(CommonFilters.SpecificSID(sid), SearchScope.Subtree, CommonProperties.TypeResolutionProps, |
+| | 0 | 288 | | rDomain) |
+| | 0 | 289 | | .DefaultIfEmpty(null).FirstOrDefault(); |
+| | | 290 | | |
+| | 0 | 291 | | type = result?.GetLabel() ?? Label.Base; |
+| | 0 | 292 | | Cache.AddType(sid, type); |
+| | 0 | 293 | | return type; |
+| | 0 | 294 | | } |
+| | | 295 | | |
+| | | 296 | | /// <summary> |
+| | | 297 | | /// Attempts to lookup the Label for a GUID |
+| | | 298 | | /// </summary> |
+| | | 299 | | /// <param name="guid"></param> |
+| | | 300 | | /// <param name="domain"></param> |
+| | | 301 | | /// <returns></returns> |
+| | | 302 | | public Label LookupGuidType(string guid, string domain) |
+| | 0 | 303 | | { |
+| | 0 | 304 | | if (Cache.GetIDType(guid, out var type)) |
+| | 0 | 305 | | return type; |
+| | | 306 | | |
+| | 0 | 307 | | var hex = Helpers.ConvertGuidToHexGuid(guid); |
+| | 0 | 308 | | if (hex == null) |
+| | 0 | 309 | | return Label.Base; |
+| | | 310 | | |
+| | 0 | 311 | | var result = |
+| | 0 | 312 | | QueryLDAP($"(objectguid={hex})", SearchScope.Subtree, CommonProperties.TypeResolutionProps, domain) |
+| | 0 | 313 | | .DefaultIfEmpty(null).FirstOrDefault(); |
+| | | 314 | | |
+| | 0 | 315 | | type = result?.GetLabel() ?? Label.Base; |
+| | 0 | 316 | | Cache.AddType(guid, type); |
+| | 0 | 317 | | return type; |
+| | 0 | 318 | | } |
+| | | 319 | | |
+| | | 320 | | /// <summary> |
+| | | 321 | | /// Attempts to find the domain associated with a SID |
+| | | 322 | | /// </summary> |
+| | | 323 | | /// <param name="sid"></param> |
+| | | 324 | | /// <returns></returns> |
+| | | 325 | | public string GetDomainNameFromSid(string sid) |
+| | 0 | 326 | | { |
+| | | 327 | | try |
+| | 0 | 328 | | { |
+| | 0 | 329 | | var parsedSid = new SecurityIdentifier(sid); |
+| | 0 | 330 | | var domainSid = parsedSid.AccountDomainSid?.Value.ToUpper(); |
+| | 0 | 331 | | if (domainSid == null) |
+| | 0 | 332 | | return null; |
+| | | 333 | | |
+| | 0 | 334 | | _log.LogDebug("Resolving sid {DomainSid}", domainSid); |
+| | | 335 | | |
+| | 0 | 336 | | if (Cache.GetDomainSidMapping(domainSid, out var domain)) |
+| | 0 | 337 | | return domain; |
+| | | 338 | | |
+| | 0 | 339 | | _log.LogDebug("No cache hit for {DomainSid}", domainSid); |
+| | 0 | 340 | | domain = GetDomainNameFromSidLdap(domainSid); |
+| | 0 | 341 | | _log.LogDebug("Resolved to {Domain}", domain); |
+| | | 342 | | |
+| | | 343 | | //Cache both to and from so we can use this later |
+| | 0 | 344 | | if (domain != null) |
+| | 0 | 345 | | { |
+| | 0 | 346 | | Cache.AddSidToDomain(domainSid, domain); |
+| | 0 | 347 | | Cache.AddSidToDomain(domain, domainSid); |
+| | 0 | 348 | | } |
+| | | 349 | | |
+| | 0 | 350 | | return domain; |
+| | | 351 | | } |
+| | 0 | 352 | | catch |
+| | 0 | 353 | | { |
+| | 0 | 354 | | return null; |
+| | | 355 | | } |
+| | 0 | 356 | | } |
+| | | 357 | | |
+| | | 358 | | /// <summary> |
+| | | 359 | | /// Attempts to get the SID associated with a domain name |
+| | | 360 | | /// </summary> |
+| | | 361 | | /// <param name="domainName"></param> |
+| | | 362 | | /// <returns></returns> |
+| | | 363 | | public string GetSidFromDomainName(string domainName) |
+| | 0 | 364 | | { |
+| | 0 | 365 | | var tempDomainName = NormalizeDomainName(domainName); |
+| | 0 | 366 | | if (tempDomainName == null) |
+| | 0 | 367 | | return null; |
+| | 0 | 368 | | if (Cache.GetDomainSidMapping(tempDomainName, out var sid)) return sid; |
+| | | 369 | | |
+| | 0 | 370 | | var domainObj = GetDomain(tempDomainName); |
+| | | 371 | | |
+| | 0 | 372 | | if (domainObj != null) |
+| | 0 | 373 | | sid = domainObj.GetDirectoryEntry().GetSid(); |
+| | | 374 | | else |
+| | 0 | 375 | | sid = null; |
+| | | 376 | | |
+| | 0 | 377 | | if (sid != null) |
+| | 0 | 378 | | { |
+| | 0 | 379 | | Cache.AddSidToDomain(sid, tempDomainName); |
+| | 0 | 380 | | Cache.AddSidToDomain(tempDomainName, sid); |
+| | 0 | 381 | | } |
+| | | 382 | | |
+| | 0 | 383 | | return sid; |
+| | 0 | 384 | | } |
+| | | 385 | | |
+| | | 386 | | // Saving this code for an eventual async implementation |
+| | | 387 | | // public async IAsyncEnumerable<string> DoRangedRetrievalAsync(string distinguishedName, string attributeName) |
+| | | 388 | | // { |
+| | | 389 | | // var domainName = Helpers.DistinguishedNameToDomain(distinguishedName); |
+| | | 390 | | // LdapConnection conn; |
+| | | 391 | | // try |
+| | | 392 | | // { |
+| | | 393 | | // conn = await CreateLDAPConnection(domainName, authType: _ldapConfig.AuthType); |
+| | | 394 | | // } |
+| | | 395 | | // catch |
+| | | 396 | | // { |
+| | | 397 | | // yield break; |
+| | | 398 | | // } |
+| | | 399 | | // |
+| | | 400 | | // if (conn == null) |
+| | | 401 | | // yield break; |
+| | | 402 | | // |
+| | | 403 | | // var index = 0; |
+| | | 404 | | // var step = 0; |
+| | | 405 | | // var currentRange = $"{attributeName};range={index}-*"; |
+| | | 406 | | // var complete = false; |
+| | | 407 | | // |
+| | | 408 | | // var searchRequest = CreateSearchRequest($"{attributeName}=*", SearchScope.Base, new[] {currentRange}, |
+| | | 409 | | // domainName, distinguishedName); |
+| | | 410 | | // |
+| | | 411 | | // var backoffDelay = MinBackoffDelay; |
+| | | 412 | | // var retryCount = 0; |
+| | | 413 | | // |
+| | | 414 | | // while (true) |
+| | | 415 | | // { |
+| | | 416 | | // DirectoryResponse searchResult; |
+| | | 417 | | // try |
+| | | 418 | | // { |
+| | | 419 | | // searchResult = await Task.Factory.FromAsync(conn.BeginSendRequest, conn.EndSendRequest, |
+| | | 420 | | // searchRequest, |
+| | | 421 | | // PartialResultProcessing.NoPartialResultSupport, null); |
+| | | 422 | | // } |
+| | | 423 | | // catch (LdapException le) when (le.ErrorCode == 51 && retryCount < MaxRetries) |
+| | | 424 | | // { |
+| | | 425 | | // //Allow three retries with a backoff on each one if we get a "Server is Busy" error |
+| | | 426 | | // retryCount++; |
+| | | 427 | | // await Task.Delay(backoffDelay); |
+| | | 428 | | // backoffDelay = TimeSpan.FromSeconds(Math.Min( |
+| | | 429 | | // backoffDelay.TotalSeconds * BackoffDelayMultiplier.TotalSeconds, MaxBackoffDelay.TotalSeconds |
+| | | 430 | | // continue; |
+| | | 431 | | // } |
+| | | 432 | | // catch (Exception e) |
+| | | 433 | | // { |
+| | | 434 | | // _log.LogWarning(e,"Caught exception during ranged retrieval for {DN}", distinguishedName); |
+| | | 435 | | // yield break; |
+| | | 436 | | // } |
+| | | 437 | | // |
+| | | 438 | | // if (searchResult is SearchResponse response && response.Entries.Count == 1) |
+| | | 439 | | // { |
+| | | 440 | | // var entry = response.Entries[0]; |
+| | | 441 | | // var attributeNames = entry?.Attributes?.AttributeNames; |
+| | | 442 | | // if (attributeNames != null) |
+| | | 443 | | // { |
+| | | 444 | | // foreach (string attr in attributeNames) |
+| | | 445 | | // { |
+| | | 446 | | // //Set our current range to the name of the attribute, which will tell us how far we are i |
+| | | 447 | | // currentRange = attr; |
+| | | 448 | | // //Check if the string has the * character in it. If it does, we've reached the end of thi |
+| | | 449 | | // complete = currentRange.IndexOf("*", 0, StringComparison.Ordinal) > 0; |
+| | | 450 | | // //Set our step to the number of attributes that came back. |
+| | | 451 | | // step = entry.Attributes[currentRange].Count; |
+| | | 452 | | // } |
+| | | 453 | | // } |
+| | | 454 | | // |
+| | | 455 | | // |
+| | | 456 | | // foreach (string val in entry.Attributes[currentRange].GetValues(typeof(string))) |
+| | | 457 | | // { |
+| | | 458 | | // yield return val; |
+| | | 459 | | // index++; |
+| | | 460 | | // } |
+| | | 461 | | // |
+| | | 462 | | // if (complete) yield break; |
+| | | 463 | | // |
+| | | 464 | | // currentRange = $"{attributeName};range={index}-{index + step}"; |
+| | | 465 | | // searchRequest.Attributes.Clear(); |
+| | | 466 | | // searchRequest.Attributes.Add(currentRange); |
+| | | 467 | | // } |
+| | | 468 | | // else |
+| | | 469 | | // { |
+| | | 470 | | // yield break; |
+| | | 471 | | // } |
+| | | 472 | | // } |
+| | | 473 | | // } |
+| | | 474 | | |
+| | | 475 | | /// <summary> |
+| | | 476 | | /// Performs Attribute Ranged Retrieval |
+| | | 477 | | /// https://docs.microsoft.com/en-us/windows/win32/adsi/attribute-range-retrieval |
+| | | 478 | | /// The function self-determines the range and internally handles the maximum step allowed by the server |
+| | | 479 | | /// </summary> |
+| | | 480 | | /// <param name="distinguishedName"></param> |
+| | | 481 | | /// <param name="attributeName"></param> |
+| | | 482 | | /// <returns></returns> |
+| | | 483 | | public IEnumerable<string> DoRangedRetrieval(string distinguishedName, string attributeName) |
+| | 0 | 484 | | { |
+| | 0 | 485 | | var domainName = Helpers.DistinguishedNameToDomain(distinguishedName); |
+| | 0 | 486 | | var task = Task.Run(() => CreateLDAPConnection(domainName, authType: _ldapConfig.AuthType)); |
+| | | 487 | | |
+| | | 488 | | LdapConnection conn; |
+| | | 489 | | |
+| | | 490 | | try |
+| | 0 | 491 | | { |
+| | 0 | 492 | | conn = task.ConfigureAwait(false).GetAwaiter().GetResult(); |
+| | 0 | 493 | | } |
+| | 0 | 494 | | catch |
+| | 0 | 495 | | { |
+| | 0 | 496 | | yield break; |
+| | | 497 | | } |
| | | 498 | | |
-| | 0 | 499 | | var searchRequest = CreateSearchRequest($"{attributeName}=*", SearchScope.Base, new[] { currentRange }, |
-| | 0 | 500 | | domainName, distinguishedName); |
+| | 0 | 499 | | if (conn == null) |
+| | 0 | 500 | | yield break; |
| | | 501 | | |
-| | 0 | 502 | | if (searchRequest == null) |
-| | 0 | 503 | | yield break; |
-| | | 504 | | |
-| | 0 | 505 | | var backoffDelay = MinBackoffDelay; |
-| | 0 | 506 | | var retryCount = 0; |
-| | | 507 | | |
-| | 0 | 508 | | while (true) |
-| | 0 | 509 | | { |
-| | | 510 | | SearchResponse response; |
-| | | 511 | | try |
-| | 0 | 512 | | { |
-| | 0 | 513 | | response = (SearchResponse)conn.SendRequest(searchRequest); |
-| | 0 | 514 | | } |
-| | 0 | 515 | | catch (LdapException le) when (le.ErrorCode == (int)LdapErrorCodes.Busy && retryCount < MaxRetries) |
-| | 0 | 516 | | { |
-| | | 517 | | //Allow three retries with a backoff on each one if we get a "Server is Busy" error |
-| | 0 | 518 | | retryCount++; |
-| | 0 | 519 | | Thread.Sleep(backoffDelay); |
-| | 0 | 520 | | backoffDelay = TimeSpan.FromSeconds(Math.Min( |
-| | 0 | 521 | | backoffDelay.TotalSeconds * BackoffDelayMultiplier.TotalSeconds, MaxBackoffDelay.TotalSeconds)); |
-| | 0 | 522 | | continue; |
-| | | 523 | | } |
-| | 0 | 524 | | catch (Exception e) |
-| | 0 | 525 | | { |
-| | 0 | 526 | | _log.LogError(e, "Error doing ranged retrieval for {Attribute} on {Dn}", attributeName, distinguishe |
-| | 0 | 527 | | yield break; |
-| | | 528 | | } |
-| | | 529 | | |
-| | | 530 | | //If we ever get more than one response from here, something is horribly wrong |
-| | 0 | 531 | | if (response?.Entries.Count == 1) |
-| | 0 | 532 | | { |
-| | 0 | 533 | | var entry = response.Entries[0]; |
-| | | 534 | | //Process the attribute we get back to determine a few things |
-| | 0 | 535 | | foreach (string attr in entry.Attributes.AttributeNames) |
-| | 0 | 536 | | { |
-| | | 537 | | //Set our current range to the name of the attribute, which will tell us how far we are in "pagi |
-| | 0 | 538 | | currentRange = attr; |
-| | | 539 | | //Check if the string has the * character in it. If it does, we've reached the end of this searc |
-| | 0 | 540 | | complete = currentRange.IndexOf("*", 0, StringComparison.Ordinal) > 0; |
-| | | 541 | | //Set our step to the number of attributes that came back. |
-| | 0 | 542 | | step = entry.Attributes[currentRange].Count; |
-| | 0 | 543 | | } |
-| | | 544 | | |
-| | 0 | 545 | | foreach (string val in entry.Attributes[currentRange].GetValues(typeof(string))) |
+| | 0 | 502 | | var index = 0; |
+| | 0 | 503 | | var step = 0; |
+| | 0 | 504 | | var baseString = $"{attributeName}"; |
+| | | 505 | | //Example search string: member;range=0-1000 |
+| | 0 | 506 | | var currentRange = $"{baseString};range={index}-*"; |
+| | 0 | 507 | | var complete = false; |
+| | | 508 | | |
+| | 0 | 509 | | var searchRequest = CreateSearchRequest($"{attributeName}=*", SearchScope.Base, new[] { currentRange }, |
+| | 0 | 510 | | domainName, distinguishedName); |
+| | | 511 | | |
+| | 0 | 512 | | if (searchRequest == null) |
+| | 0 | 513 | | yield break; |
+| | | 514 | | |
+| | 0 | 515 | | var backoffDelay = MinBackoffDelay; |
+| | 0 | 516 | | var retryCount = 0; |
+| | | 517 | | |
+| | 0 | 518 | | while (true) |
+| | 0 | 519 | | { |
+| | | 520 | | SearchResponse response; |
+| | | 521 | | try |
+| | 0 | 522 | | { |
+| | 0 | 523 | | response = (SearchResponse)conn.SendRequest(searchRequest); |
+| | 0 | 524 | | } |
+| | 0 | 525 | | catch (LdapException le) when (le.ErrorCode == (int)LdapErrorCodes.Busy && retryCount < MaxRetries) |
+| | 0 | 526 | | { |
+| | | 527 | | //Allow three retries with a backoff on each one if we get a "Server is Busy" error |
+| | 0 | 528 | | retryCount++; |
+| | 0 | 529 | | Thread.Sleep(backoffDelay); |
+| | 0 | 530 | | backoffDelay = GetNextBackoff(retryCount); |
+| | 0 | 531 | | continue; |
+| | | 532 | | } |
+| | 0 | 533 | | catch (Exception e) |
+| | 0 | 534 | | { |
+| | 0 | 535 | | _log.LogError(e, "Error doing ranged retrieval for {Attribute} on {Dn}", attributeName, |
+| | 0 | 536 | | distinguishedName); |
+| | 0 | 537 | | yield break; |
+| | | 538 | | } |
+| | | 539 | | |
+| | | 540 | | //If we ever get more than one response from here, something is horribly wrong |
+| | 0 | 541 | | if (response?.Entries.Count == 1) |
+| | 0 | 542 | | { |
+| | 0 | 543 | | var entry = response.Entries[0]; |
+| | | 544 | | //Process the attribute we get back to determine a few things |
+| | 0 | 545 | | foreach (string attr in entry.Attributes.AttributeNames) |
| | 0 | 546 | | { |
-| | 0 | 547 | | yield return val; |
-| | 0 | 548 | | index++; |
-| | 0 | 549 | | } |
-| | | 550 | | |
-| | 0 | 551 | | if (complete) yield break; |
-| | | 552 | | |
-| | 0 | 553 | | currentRange = $"{baseString};range={index}-{index + step}"; |
-| | 0 | 554 | | searchRequest.Attributes.Clear(); |
-| | 0 | 555 | | searchRequest.Attributes.Add(currentRange); |
-| | 0 | 556 | | } |
-| | | 557 | | else |
-| | 0 | 558 | | { |
-| | | 559 | | //Something went wrong here. |
-| | 0 | 560 | | yield break; |
-| | | 561 | | } |
-| | 0 | 562 | | } |
-| | | 563 | | } |
-| | | 564 | | |
-| | | 565 | | /// <summary> |
-| | | 566 | | /// Takes a host in most applicable forms from AD and attempts to resolve it into a SID. |
-| | | 567 | | /// </summary> |
-| | | 568 | | /// <param name="hostname"></param> |
-| | | 569 | | /// <param name="domain"></param> |
-| | | 570 | | /// <returns></returns> |
-| | | 571 | | public async Task<string> ResolveHostToSid(string hostname, string domain) |
-| | 0 | 572 | | { |
-| | 0 | 573 | | var strippedHost = Helpers.StripServicePrincipalName(hostname).ToUpper().TrimEnd('$'); |
+| | | 547 | | //Set our current range to the name of the attribute, which will tell us how far we are in "pagi |
+| | 0 | 548 | | currentRange = attr; |
+| | | 549 | | //Check if the string has the * character in it. If it does, we've reached the end of this searc |
+| | 0 | 550 | | complete = currentRange.IndexOf("*", 0, StringComparison.Ordinal) > 0; |
+| | | 551 | | //Set our step to the number of attributes that came back. |
+| | 0 | 552 | | step = entry.Attributes[currentRange].Count; |
+| | 0 | 553 | | } |
+| | | 554 | | |
+| | 0 | 555 | | foreach (string val in entry.Attributes[currentRange].GetValues(typeof(string))) |
+| | 0 | 556 | | { |
+| | 0 | 557 | | yield return val; |
+| | 0 | 558 | | index++; |
+| | 0 | 559 | | } |
+| | | 560 | | |
+| | 0 | 561 | | if (complete) yield break; |
+| | | 562 | | |
+| | 0 | 563 | | currentRange = $"{baseString};range={index}-{index + step}"; |
+| | 0 | 564 | | searchRequest.Attributes.Clear(); |
+| | 0 | 565 | | searchRequest.Attributes.Add(currentRange); |
+| | 0 | 566 | | } |
+| | | 567 | | else |
+| | 0 | 568 | | { |
+| | | 569 | | //Something went wrong here. |
+| | 0 | 570 | | yield break; |
+| | | 571 | | } |
+| | 0 | 572 | | } |
+| | | 573 | | } |
| | | 574 | | |
-| | 0 | 575 | | if (_hostResolutionMap.TryGetValue(strippedHost, out var sid)) return sid; |
-| | | 576 | | |
-| | 0 | 577 | | var normalDomain = NormalizeDomainName(domain); |
-| | | 578 | | |
-| | | 579 | | string tempName; |
-| | 0 | 580 | | string tempDomain = null; |
-| | | 581 | | |
-| | | 582 | | //Step 1: Handle non-IP address values |
-| | 0 | 583 | | if (!IPAddress.TryParse(strippedHost, out _)) |
-| | 0 | 584 | | { |
-| | | 585 | | // Format: ABC.TESTLAB.LOCAL |
-| | 0 | 586 | | if (strippedHost.Contains(".")) |
-| | 0 | 587 | | { |
-| | 0 | 588 | | var split = strippedHost.Split('.'); |
-| | 0 | 589 | | tempName = split[0]; |
-| | 0 | 590 | | tempDomain = string.Join(".", split.Skip(1).ToArray()); |
-| | 0 | 591 | | } |
-| | | 592 | | // Format: WINDOWS |
-| | | 593 | | else |
-| | 0 | 594 | | { |
-| | 0 | 595 | | tempName = strippedHost; |
-| | 0 | 596 | | tempDomain = normalDomain; |
-| | 0 | 597 | | } |
-| | | 598 | | |
-| | | 599 | | // Add $ to the end of the name to match how computers are stored in AD |
-| | 0 | 600 | | tempName = $"{tempName}$".ToUpper(); |
-| | 0 | 601 | | var principal = ResolveAccountName(tempName, tempDomain); |
-| | 0 | 602 | | sid = principal?.ObjectIdentifier; |
-| | 0 | 603 | | if (sid != null) |
-| | 0 | 604 | | { |
-| | 0 | 605 | | _hostResolutionMap.TryAdd(strippedHost, sid); |
-| | 0 | 606 | | return sid; |
-| | | 607 | | } |
-| | 0 | 608 | | } |
-| | | 609 | | |
-| | | 610 | | //Step 2: Try NetWkstaGetInfo |
-| | | 611 | | //Next we'll try calling NetWkstaGetInfo in hopes of getting the NETBIOS name directly from the computer |
-| | | 612 | | //We'll use the hostname that we started with instead of the one from our previous step |
-| | 0 | 613 | | var workstationInfo = await GetWorkstationInfo(strippedHost); |
-| | 0 | 614 | | if (workstationInfo.HasValue) |
-| | 0 | 615 | | { |
-| | 0 | 616 | | tempName = workstationInfo.Value.ComputerName; |
-| | 0 | 617 | | tempDomain = workstationInfo.Value.LanGroup; |
-| | | 618 | | |
-| | 0 | 619 | | if (string.IsNullOrEmpty(tempDomain)) |
-| | 0 | 620 | | tempDomain = normalDomain; |
-| | | 621 | | |
-| | 0 | 622 | | if (!string.IsNullOrEmpty(tempName)) |
-| | 0 | 623 | | { |
-| | | 624 | | //Append the $ to indicate this is a computer |
-| | 0 | 625 | | tempName = $"{tempName}$".ToUpper(); |
-| | 0 | 626 | | var principal = ResolveAccountName(tempName, tempDomain); |
-| | 0 | 627 | | sid = principal?.ObjectIdentifier; |
-| | 0 | 628 | | if (sid != null) |
-| | 0 | 629 | | { |
-| | 0 | 630 | | _hostResolutionMap.TryAdd(strippedHost, sid); |
-| | 0 | 631 | | return sid; |
-| | | 632 | | } |
-| | 0 | 633 | | } |
-| | 0 | 634 | | } |
+| | | 575 | | /// <summary> |
+| | | 576 | | /// Takes a host in most applicable forms from AD and attempts to resolve it into a SID. |
+| | | 577 | | /// </summary> |
+| | | 578 | | /// <param name="hostname"></param> |
+| | | 579 | | /// <param name="domain"></param> |
+| | | 580 | | /// <returns></returns> |
+| | | 581 | | public async Task<string> ResolveHostToSid(string hostname, string domain) |
+| | 0 | 582 | | { |
+| | 0 | 583 | | var strippedHost = Helpers.StripServicePrincipalName(hostname).ToUpper().TrimEnd('$'); |
+| | 0 | 584 | | if (string.IsNullOrEmpty(strippedHost)) |
+| | 0 | 585 | | { |
+| | 0 | 586 | | return null; |
+| | | 587 | | } |
+| | | 588 | | |
+| | 0 | 589 | | if (_hostResolutionMap.TryGetValue(strippedHost, out var sid)) return sid; |
+| | | 590 | | |
+| | 0 | 591 | | var normalDomain = NormalizeDomainName(domain); |
+| | | 592 | | |
+| | | 593 | | string tempName; |
+| | 0 | 594 | | string tempDomain = null; |
+| | | 595 | | |
+| | | 596 | | //Step 1: Handle non-IP address values |
+| | 0 | 597 | | if (!IPAddress.TryParse(strippedHost, out _)) |
+| | 0 | 598 | | { |
+| | | 599 | | // Format: ABC.TESTLAB.LOCAL |
+| | 0 | 600 | | if (strippedHost.Contains(".")) |
+| | 0 | 601 | | { |
+| | 0 | 602 | | var split = strippedHost.Split('.'); |
+| | 0 | 603 | | tempName = split[0]; |
+| | 0 | 604 | | tempDomain = string.Join(".", split.Skip(1).ToArray()); |
+| | 0 | 605 | | } |
+| | | 606 | | // Format: WINDOWS |
+| | | 607 | | else |
+| | 0 | 608 | | { |
+| | 0 | 609 | | tempName = strippedHost; |
+| | 0 | 610 | | tempDomain = normalDomain; |
+| | 0 | 611 | | } |
+| | | 612 | | |
+| | | 613 | | // Add $ to the end of the name to match how computers are stored in AD |
+| | 0 | 614 | | tempName = $"{tempName}$".ToUpper(); |
+| | 0 | 615 | | var principal = ResolveAccountName(tempName, tempDomain); |
+| | 0 | 616 | | sid = principal?.ObjectIdentifier; |
+| | 0 | 617 | | if (sid != null) |
+| | 0 | 618 | | { |
+| | 0 | 619 | | _hostResolutionMap.TryAdd(strippedHost, sid); |
+| | 0 | 620 | | return sid; |
+| | | 621 | | } |
+| | 0 | 622 | | } |
+| | | 623 | | |
+| | | 624 | | //Step 2: Try NetWkstaGetInfo |
+| | | 625 | | //Next we'll try calling NetWkstaGetInfo in hopes of getting the NETBIOS name directly from the computer |
+| | | 626 | | //We'll use the hostname that we started with instead of the one from our previous step |
+| | 0 | 627 | | var workstationInfo = await GetWorkstationInfo(strippedHost); |
+| | 0 | 628 | | if (workstationInfo.HasValue) |
+| | 0 | 629 | | { |
+| | 0 | 630 | | tempName = workstationInfo.Value.ComputerName; |
+| | 0 | 631 | | tempDomain = workstationInfo.Value.LanGroup; |
+| | | 632 | | |
+| | 0 | 633 | | if (string.IsNullOrEmpty(tempDomain)) |
+| | 0 | 634 | | tempDomain = normalDomain; |
| | | 635 | | |
-| | | 636 | | //Step 3: Socket magic |
-| | | 637 | | // Attempt to request the NETBIOS name of the computer directly |
-| | 0 | 638 | | if (RequestNETBIOSNameFromComputer(strippedHost, normalDomain, out tempName)) |
-| | 0 | 639 | | { |
-| | 0 | 640 | | tempDomain ??= normalDomain; |
-| | 0 | 641 | | tempName = $"{tempName}$".ToUpper(); |
-| | | 642 | | |
-| | 0 | 643 | | var principal = ResolveAccountName(tempName, tempDomain); |
-| | 0 | 644 | | sid = principal?.ObjectIdentifier; |
-| | 0 | 645 | | if (sid != null) |
-| | 0 | 646 | | { |
-| | 0 | 647 | | _hostResolutionMap.TryAdd(strippedHost, sid); |
-| | 0 | 648 | | return sid; |
-| | | 649 | | } |
-| | 0 | 650 | | } |
-| | | 651 | | |
-| | | 652 | | //Try DNS resolution next |
-| | | 653 | | string resolvedHostname; |
-| | | 654 | | try |
-| | 0 | 655 | | { |
-| | 0 | 656 | | resolvedHostname = (await Dns.GetHostEntryAsync(strippedHost)).HostName; |
-| | 0 | 657 | | } |
-| | 0 | 658 | | catch |
-| | 0 | 659 | | { |
-| | 0 | 660 | | resolvedHostname = null; |
-| | 0 | 661 | | } |
-| | | 662 | | |
-| | 0 | 663 | | if (resolvedHostname != null) |
-| | 0 | 664 | | { |
-| | 0 | 665 | | var splitName = resolvedHostname.Split('.'); |
-| | 0 | 666 | | tempName = $"{splitName[0]}$".ToUpper(); |
-| | 0 | 667 | | tempDomain = string.Join(".", splitName.Skip(1)); |
-| | | 668 | | |
-| | 0 | 669 | | var principal = ResolveAccountName(tempName, tempDomain); |
-| | 0 | 670 | | sid = principal?.ObjectIdentifier; |
-| | 0 | 671 | | if (sid != null) |
-| | 0 | 672 | | { |
-| | 0 | 673 | | _hostResolutionMap.TryAdd(strippedHost, sid); |
-| | 0 | 674 | | return sid; |
-| | | 675 | | } |
-| | 0 | 676 | | } |
-| | | 677 | | |
-| | | 678 | | //If we get here, everything has failed, and life is very sad. |
-| | 0 | 679 | | tempName = strippedHost; |
-| | 0 | 680 | | tempDomain = normalDomain; |
-| | | 681 | | |
-| | 0 | 682 | | if (tempName.Contains(".")) |
-| | 0 | 683 | | { |
-| | 0 | 684 | | _hostResolutionMap.TryAdd(strippedHost, tempName); |
-| | 0 | 685 | | return tempName; |
-| | | 686 | | } |
-| | | 687 | | |
-| | 0 | 688 | | tempName = $"{tempName}.{tempDomain}"; |
-| | 0 | 689 | | _hostResolutionMap.TryAdd(strippedHost, tempName); |
-| | 0 | 690 | | return tempName; |
-| | 0 | 691 | | } |
-| | | 692 | | |
-| | | 693 | | /// <summary> |
-| | | 694 | | /// Attempts to convert a bare account name (usually from session enumeration) to its corresponding ID and o |
-| | | 695 | | /// </summary> |
-| | | 696 | | /// <param name="name"></param> |
-| | | 697 | | /// <param name="domain"></param> |
-| | | 698 | | /// <returns></returns> |
-| | | 699 | | public TypedPrincipal ResolveAccountName(string name, string domain) |
-| | 0 | 700 | | { |
-| | 0 | 701 | | if (string.IsNullOrWhiteSpace(name)) |
-| | 0 | 702 | | return null; |
-| | | 703 | | |
-| | 0 | 704 | | if (Cache.GetPrefixedValue(name, domain, out var id) && Cache.GetIDType(id, out var type)) |
-| | 0 | 705 | | return new TypedPrincipal |
-| | 0 | 706 | | { |
-| | 0 | 707 | | ObjectIdentifier = id, |
-| | 0 | 708 | | ObjectType = type |
-| | 0 | 709 | | }; |
-| | | 710 | | |
-| | 0 | 711 | | var d = NormalizeDomainName(domain); |
-| | 0 | 712 | | var result = QueryLDAP($"(samaccountname={name})", SearchScope.Subtree, |
-| | 0 | 713 | | CommonProperties.TypeResolutionProps, |
-| | 0 | 714 | | d).DefaultIfEmpty(null).FirstOrDefault(); |
-| | | 715 | | |
-| | 0 | 716 | | if (result == null) |
-| | 0 | 717 | | { |
-| | 0 | 718 | | _log.LogDebug("ResolveAccountName - unable to get result for {Name}", name); |
-| | 0 | 719 | | return null; |
-| | | 720 | | } |
-| | | 721 | | |
-| | 0 | 722 | | type = result.GetLabel(); |
-| | 0 | 723 | | id = result.GetObjectIdentifier(); |
+| | 0 | 636 | | if (!string.IsNullOrEmpty(tempName)) |
+| | 0 | 637 | | { |
+| | | 638 | | //Append the $ to indicate this is a computer |
+| | 0 | 639 | | tempName = $"{tempName}$".ToUpper(); |
+| | 0 | 640 | | var principal = ResolveAccountName(tempName, tempDomain); |
+| | 0 | 641 | | sid = principal?.ObjectIdentifier; |
+| | 0 | 642 | | if (sid != null) |
+| | 0 | 643 | | { |
+| | 0 | 644 | | _hostResolutionMap.TryAdd(strippedHost, sid); |
+| | 0 | 645 | | return sid; |
+| | | 646 | | } |
+| | 0 | 647 | | } |
+| | 0 | 648 | | } |
+| | | 649 | | |
+| | | 650 | | //Step 3: Socket magic |
+| | | 651 | | // Attempt to request the NETBIOS name of the computer directly |
+| | 0 | 652 | | if (RequestNETBIOSNameFromComputer(strippedHost, normalDomain, out tempName)) |
+| | 0 | 653 | | { |
+| | 0 | 654 | | tempDomain ??= normalDomain; |
+| | 0 | 655 | | tempName = $"{tempName}$".ToUpper(); |
+| | | 656 | | |
+| | 0 | 657 | | var principal = ResolveAccountName(tempName, tempDomain); |
+| | 0 | 658 | | sid = principal?.ObjectIdentifier; |
+| | 0 | 659 | | if (sid != null) |
+| | 0 | 660 | | { |
+| | 0 | 661 | | _hostResolutionMap.TryAdd(strippedHost, sid); |
+| | 0 | 662 | | return sid; |
+| | | 663 | | } |
+| | 0 | 664 | | } |
+| | | 665 | | |
+| | | 666 | | //Try DNS resolution next |
+| | | 667 | | string resolvedHostname; |
+| | | 668 | | try |
+| | 0 | 669 | | { |
+| | 0 | 670 | | resolvedHostname = (await Dns.GetHostEntryAsync(strippedHost)).HostName; |
+| | 0 | 671 | | } |
+| | 0 | 672 | | catch |
+| | 0 | 673 | | { |
+| | 0 | 674 | | resolvedHostname = null; |
+| | 0 | 675 | | } |
+| | | 676 | | |
+| | 0 | 677 | | if (resolvedHostname != null) |
+| | 0 | 678 | | { |
+| | 0 | 679 | | var splitName = resolvedHostname.Split('.'); |
+| | 0 | 680 | | tempName = $"{splitName[0]}$".ToUpper(); |
+| | 0 | 681 | | tempDomain = string.Join(".", splitName.Skip(1)); |
+| | | 682 | | |
+| | 0 | 683 | | var principal = ResolveAccountName(tempName, tempDomain); |
+| | 0 | 684 | | sid = principal?.ObjectIdentifier; |
+| | 0 | 685 | | if (sid != null) |
+| | 0 | 686 | | { |
+| | 0 | 687 | | _hostResolutionMap.TryAdd(strippedHost, sid); |
+| | 0 | 688 | | return sid; |
+| | | 689 | | } |
+| | 0 | 690 | | } |
+| | | 691 | | |
+| | | 692 | | //If we get here, everything has failed, and life is very sad. |
+| | 0 | 693 | | tempName = strippedHost; |
+| | 0 | 694 | | tempDomain = normalDomain; |
+| | | 695 | | |
+| | 0 | 696 | | if (tempName.Contains(".")) |
+| | 0 | 697 | | { |
+| | 0 | 698 | | _hostResolutionMap.TryAdd(strippedHost, tempName); |
+| | 0 | 699 | | return tempName; |
+| | | 700 | | } |
+| | | 701 | | |
+| | 0 | 702 | | tempName = $"{tempName}.{tempDomain}"; |
+| | 0 | 703 | | _hostResolutionMap.TryAdd(strippedHost, tempName); |
+| | 0 | 704 | | return tempName; |
+| | 0 | 705 | | } |
+| | | 706 | | |
+| | | 707 | | /// <summary> |
+| | | 708 | | /// Attempts to convert a bare account name (usually from session enumeration) to its corresponding ID and o |
+| | | 709 | | /// </summary> |
+| | | 710 | | /// <param name="name"></param> |
+| | | 711 | | /// <param name="domain"></param> |
+| | | 712 | | /// <returns></returns> |
+| | | 713 | | public TypedPrincipal ResolveAccountName(string name, string domain) |
+| | 0 | 714 | | { |
+| | 0 | 715 | | if (string.IsNullOrWhiteSpace(name)) |
+| | 0 | 716 | | return null; |
+| | | 717 | | |
+| | 0 | 718 | | if (Cache.GetPrefixedValue(name, domain, out var id) && Cache.GetIDType(id, out var type)) |
+| | 0 | 719 | | return new TypedPrincipal |
+| | 0 | 720 | | { |
+| | 0 | 721 | | ObjectIdentifier = id, |
+| | 0 | 722 | | ObjectType = type |
+| | 0 | 723 | | }; |
| | | 724 | | |
-| | 0 | 725 | | if (id == null) |
-| | 0 | 726 | | { |
-| | 0 | 727 | | _log.LogDebug("ResolveAccountName - could not retrieve ID on {DN} for {Name}", result.DistinguishedName, |
-| | 0 | 728 | | name); |
-| | 0 | 729 | | return null; |
-| | | 730 | | } |
-| | | 731 | | |
-| | 0 | 732 | | Cache.AddPrefixedValue(name, domain, id); |
-| | 0 | 733 | | Cache.AddType(id, type); |
-| | | 734 | | |
-| | 0 | 735 | | id = ConvertWellKnownPrincipal(id, domain); |
-| | | 736 | | |
-| | 0 | 737 | | return new TypedPrincipal |
-| | 0 | 738 | | { |
-| | 0 | 739 | | ObjectIdentifier = id, |
-| | 0 | 740 | | ObjectType = type |
-| | 0 | 741 | | }; |
-| | 0 | 742 | | } |
-| | | 743 | | |
-| | | 744 | | /// <summary> |
-| | | 745 | | /// Attempts to convert a distinguishedname to its corresponding ID and object type. |
-| | | 746 | | /// </summary> |
-| | | 747 | | /// <param name="dn">DistinguishedName</param> |
-| | | 748 | | /// <returns>A <c>TypedPrincipal</c> object with the SID and Label</returns> |
-| | | 749 | | public TypedPrincipal ResolveDistinguishedName(string dn) |
-| | 0 | 750 | | { |
-| | 0 | 751 | | if (Cache.GetConvertedValue(dn, out var id) && Cache.GetIDType(id, out var type)) |
-| | 0 | 752 | | return new TypedPrincipal |
-| | 0 | 753 | | { |
-| | 0 | 754 | | ObjectIdentifier = id, |
-| | 0 | 755 | | ObjectType = type |
-| | 0 | 756 | | }; |
+| | 0 | 725 | | var d = NormalizeDomainName(domain); |
+| | 0 | 726 | | var result = QueryLDAP($"(samaccountname={name})", SearchScope.Subtree, |
+| | 0 | 727 | | CommonProperties.TypeResolutionProps, |
+| | 0 | 728 | | d).DefaultIfEmpty(null).FirstOrDefault(); |
+| | | 729 | | |
+| | 0 | 730 | | if (result == null) |
+| | 0 | 731 | | { |
+| | 0 | 732 | | _log.LogDebug("ResolveAccountName - unable to get result for {Name}", name); |
+| | 0 | 733 | | return null; |
+| | | 734 | | } |
+| | | 735 | | |
+| | 0 | 736 | | type = result.GetLabel(); |
+| | 0 | 737 | | id = result.GetObjectIdentifier(); |
+| | | 738 | | |
+| | 0 | 739 | | if (id == null) |
+| | 0 | 740 | | { |
+| | 0 | 741 | | _log.LogDebug("ResolveAccountName - could not retrieve ID on {DN} for {Name}", result.DistinguishedName, |
+| | 0 | 742 | | name); |
+| | 0 | 743 | | return null; |
+| | | 744 | | } |
+| | | 745 | | |
+| | 0 | 746 | | Cache.AddPrefixedValue(name, domain, id); |
+| | 0 | 747 | | Cache.AddType(id, type); |
+| | | 748 | | |
+| | 0 | 749 | | id = ConvertWellKnownPrincipal(id, domain); |
+| | | 750 | | |
+| | 0 | 751 | | return new TypedPrincipal |
+| | 0 | 752 | | { |
+| | 0 | 753 | | ObjectIdentifier = id, |
+| | 0 | 754 | | ObjectType = type |
+| | 0 | 755 | | }; |
+| | 0 | 756 | | } |
| | | 757 | | |
-| | 0 | 758 | | var domain = Helpers.DistinguishedNameToDomain(dn); |
-| | 0 | 759 | | var result = QueryLDAP("(objectclass=*)", SearchScope.Base, CommonProperties.TypeResolutionProps, domain, |
-| | 0 | 760 | | adsPath: dn) |
-| | 0 | 761 | | .DefaultIfEmpty(null).FirstOrDefault(); |
-| | | 762 | | |
-| | 0 | 763 | | if (result == null) |
-| | 0 | 764 | | { |
-| | 0 | 765 | | _log.LogDebug("ResolveDistinguishedName - No result for {DN}", dn); |
-| | 0 | 766 | | return null; |
-| | | 767 | | } |
-| | | 768 | | |
-| | 0 | 769 | | id = result.GetObjectIdentifier(); |
-| | 0 | 770 | | if (id == null) |
-| | 0 | 771 | | { |
-| | 0 | 772 | | _log.LogDebug("ResolveDistinguishedName - could not retrieve object identifier from {DN}", dn); |
-| | 0 | 773 | | return null; |
-| | | 774 | | } |
-| | | 775 | | |
-| | 0 | 776 | | if (GetWellKnownPrincipal(id, domain, out var principal)) return principal; |
-| | | 777 | | |
-| | 0 | 778 | | type = result.GetLabel(); |
-| | | 779 | | |
-| | 0 | 780 | | Cache.AddConvertedValue(dn, id); |
-| | 0 | 781 | | Cache.AddType(id, type); |
+| | | 758 | | /// <summary> |
+| | | 759 | | /// Attempts to convert a distinguishedname to its corresponding ID and object type. |
+| | | 760 | | /// </summary> |
+| | | 761 | | /// <param name="dn">DistinguishedName</param> |
+| | | 762 | | /// <returns>A <c>TypedPrincipal</c> object with the SID and Label</returns> |
+| | | 763 | | public TypedPrincipal ResolveDistinguishedName(string dn) |
+| | 0 | 764 | | { |
+| | 0 | 765 | | if (Cache.GetConvertedValue(dn, out var id) && Cache.GetIDType(id, out var type)) |
+| | 0 | 766 | | return new TypedPrincipal |
+| | 0 | 767 | | { |
+| | 0 | 768 | | ObjectIdentifier = id, |
+| | 0 | 769 | | ObjectType = type |
+| | 0 | 770 | | }; |
+| | | 771 | | |
+| | 0 | 772 | | var domain = Helpers.DistinguishedNameToDomain(dn); |
+| | 0 | 773 | | var result = QueryLDAP("(objectclass=*)", SearchScope.Base, CommonProperties.TypeResolutionProps, domain, |
+| | 0 | 774 | | adsPath: dn) |
+| | 0 | 775 | | .DefaultIfEmpty(null).FirstOrDefault(); |
+| | | 776 | | |
+| | 0 | 777 | | if (result == null) |
+| | 0 | 778 | | { |
+| | 0 | 779 | | _log.LogDebug("ResolveDistinguishedName - No result for {DN}", dn); |
+| | 0 | 780 | | return null; |
+| | | 781 | | } |
| | | 782 | | |
-| | 0 | 783 | | id = ConvertWellKnownPrincipal(id, domain); |
-| | | 784 | | |
-| | 0 | 785 | | return new TypedPrincipal |
-| | 0 | 786 | | { |
-| | 0 | 787 | | ObjectIdentifier = id, |
-| | 0 | 788 | | ObjectType = type |
-| | 0 | 789 | | }; |
-| | 0 | 790 | | } |
+| | 0 | 783 | | id = result.GetObjectIdentifier(); |
+| | 0 | 784 | | if (id == null) |
+| | 0 | 785 | | { |
+| | 0 | 786 | | _log.LogDebug("ResolveDistinguishedName - could not retrieve object identifier from {DN}", dn); |
+| | 0 | 787 | | return null; |
+| | | 788 | | } |
+| | | 789 | | |
+| | 0 | 790 | | if (GetWellKnownPrincipal(id, domain, out var principal)) return principal; |
| | | 791 | | |
-| | | 792 | | /// <summary> |
-| | | 793 | | /// Queries LDAP using LDAPQueryOptions |
-| | | 794 | | /// </summary> |
-| | | 795 | | /// <param name="options"></param> |
-| | | 796 | | /// <returns></returns> |
-| | | 797 | | public IEnumerable<ISearchResultEntry> QueryLDAP(LDAPQueryOptions options) |
-| | 2 | 798 | | { |
-| | 2 | 799 | | return QueryLDAP( |
-| | 2 | 800 | | options.Filter, |
-| | 2 | 801 | | options.Scope, |
-| | 2 | 802 | | options.Properties, |
-| | 2 | 803 | | options.CancellationToken, |
-| | 2 | 804 | | options.DomainName, |
-| | 2 | 805 | | options.IncludeAcl, |
-| | 2 | 806 | | options.ShowDeleted, |
-| | 2 | 807 | | options.AdsPath, |
-| | 2 | 808 | | options.GlobalCatalog, |
-| | 2 | 809 | | options.SkipCache, |
-| | 2 | 810 | | options.ThrowException |
-| | 2 | 811 | | ); |
-| | 2 | 812 | | } |
-| | | 813 | | |
-| | | 814 | | /// <summary> |
-| | | 815 | | /// Performs an LDAP query using the parameters specified by the user. |
-| | | 816 | | /// </summary> |
-| | | 817 | | /// <param name="ldapFilter">LDAP filter</param> |
-| | | 818 | | /// <param name="scope">SearchScope to query</param> |
-| | | 819 | | /// <param name="props">LDAP properties to fetch for each object</param> |
-| | | 820 | | /// <param name="cancellationToken">Cancellation Token</param> |
-| | | 821 | | /// <param name="includeAcl">Include the DACL and Owner values in the NTSecurityDescriptor</param> |
-| | | 822 | | /// <param name="showDeleted">Include deleted objects</param> |
-| | | 823 | | /// <param name="domainName">Domain to query</param> |
-| | | 824 | | /// <param name="adsPath">ADS path to limit the query too</param> |
-| | | 825 | | /// <param name="globalCatalog">Use the global catalog instead of the regular LDAP server</param> |
-| | | 826 | | /// <param name="skipCache"> |
-| | | 827 | | /// Skip the connection cache and force a new connection. You must dispose of this connection |
-| | | 828 | | /// yourself. |
-| | | 829 | | /// </param> |
-| | | 830 | | /// <param name="throwException">Throw exceptions rather than logging the errors directly</param> |
-| | | 831 | | /// <returns>All LDAP search results matching the specified parameters</returns> |
-| | | 832 | | /// <exception cref="LDAPQueryException"> |
-| | | 833 | | /// Thrown when an error occurs during LDAP query (only when throwException = true) |
-| | | 834 | | /// </exception> |
-| | | 835 | | public IEnumerable<ISearchResultEntry> QueryLDAP(string ldapFilter, SearchScope scope, |
-| | | 836 | | string[] props, CancellationToken cancellationToken, string domainName = null, bool includeAcl = false, |
-| | | 837 | | bool showDeleted = false, string adsPath = null, bool globalCatalog = false, bool skipCache = false, |
-| | | 838 | | bool throwException = false) |
-| | 4 | 839 | | { |
-| | 4 | 840 | | var queryParams = SetupLDAPQueryFilter( |
-| | 4 | 841 | | ldapFilter, scope, props, includeAcl, domainName, includeAcl, adsPath, globalCatalog, skipCache); |
-| | | 842 | | |
-| | 4 | 843 | | if (queryParams.Exception != null) |
-| | 4 | 844 | | { |
-| | 4 | 845 | | _log.LogWarning("Failed to setup LDAP Query Filter: {Message}", queryParams.Exception.Message); |
-| | 6 | 846 | | if (throwException) throw new LDAPQueryException("Failed to setup LDAP Query Filter", queryParams.Except |
-| | 2 | 847 | | yield break; |
-| | | 848 | | } |
-| | | 849 | | |
-| | 0 | 850 | | var conn = queryParams.Connection; |
-| | 0 | 851 | | var request = queryParams.SearchRequest; |
-| | 0 | 852 | | var pageControl = queryParams.PageControl; |
-| | | 853 | | |
-| | 0 | 854 | | PageResultResponseControl pageResponse = null; |
-| | 0 | 855 | | var backoffDelay = MinBackoffDelay; |
-| | 0 | 856 | | var retryCount = 0; |
-| | 0 | 857 | | while (true) |
-| | 0 | 858 | | { |
-| | 0 | 859 | | if (cancellationToken.IsCancellationRequested) |
-| | 0 | 860 | | yield break; |
-| | | 861 | | |
-| | | 862 | | SearchResponse response; |
-| | | 863 | | try |
-| | 0 | 864 | | { |
-| | 0 | 865 | | _log.LogTrace("Sending LDAP request for {Filter}", ldapFilter); |
-| | 0 | 866 | | response = (SearchResponse)conn.SendRequest(request); |
-| | 0 | 867 | | if (response != null) |
-| | 0 | 868 | | pageResponse = (PageResultResponseControl)response.Controls |
-| | 0 | 869 | | .Where(x => x is PageResultResponseControl).DefaultIfEmpty(null).FirstOrDefault(); |
-| | 0 | 870 | | }catch (LdapException le) when (le.ErrorCode == (int)LdapErrorCodes.ServerDown && |
-| | 0 | 871 | | retryCount < MaxRetries) |
-| | 0 | 872 | | { |
-| | 0 | 873 | | retryCount++; |
-| | 0 | 874 | | Thread.Sleep(backoffDelay); |
-| | 0 | 875 | | backoffDelay = TimeSpan.FromSeconds(Math.Min( |
-| | 0 | 876 | | backoffDelay.TotalSeconds * BackoffDelayMultiplier.TotalSeconds, MaxBackoffDelay.TotalSeconds)); |
-| | 0 | 877 | | conn = CreateNewConnection(domainName, globalCatalog, skipCache); |
-| | 0 | 878 | | if (conn == null) |
-| | 0 | 879 | | { |
-| | 0 | 880 | | _log.LogError("Unable to create replacement ldap connection for ServerDown exception. Breaking l |
-| | 0 | 881 | | yield break; |
-| | | 882 | | } |
-| | | 883 | | |
-| | 0 | 884 | | _log.LogInformation("Created new LDAP connection after receiving ServerDown from server"); |
-| | 0 | 885 | | continue; |
-| | 0 | 886 | | }catch (LdapException le) when (le.ErrorCode == (int)LdapErrorCodes.Busy && retryCount < MaxRetries) { |
-| | 0 | 887 | | retryCount++; |
-| | 0 | 888 | | Thread.Sleep(backoffDelay); |
-| | 0 | 889 | | backoffDelay = TimeSpan.FromSeconds(Math.Min( |
-| | 0 | 890 | | backoffDelay.TotalSeconds * BackoffDelayMultiplier.TotalSeconds, MaxBackoffDelay.TotalSeconds)); |
-| | 0 | 891 | | continue; |
-| | | 892 | | } |
-| | 0 | 893 | | catch (LdapException le) |
-| | 0 | 894 | | { |
-| | 0 | 895 | | if (le.ErrorCode != 82) |
-| | 0 | 896 | | if (throwException) |
-| | 0 | 897 | | throw new LDAPQueryException( |
-| | 0 | 898 | | $"LDAP Exception in Loop: {le.ErrorCode}. {le.ServerErrorMessage}. {le.Message}. Filter: |
-| | 0 | 899 | | le); |
-| | | 900 | | else |
-| | 0 | 901 | | _log.LogWarning(le, |
-| | 0 | 902 | | "LDAP Exception in Loop: {ErrorCode}. {ServerErrorMessage}. {Message}. Filter: {Filter}. |
-| | 0 | 903 | | le.ErrorCode, le.ServerErrorMessage, le.Message, ldapFilter, domainName); |
-| | | 904 | | |
-| | 0 | 905 | | yield break; |
-| | | 906 | | } |
-| | 0 | 907 | | catch (Exception e) |
-| | 0 | 908 | | { |
-| | 0 | 909 | | _log.LogWarning(e, "Exception in LDAP loop for {Filter} and {Domain}", ldapFilter, domainName); |
-| | 0 | 910 | | if (throwException) |
-| | 0 | 911 | | throw new LDAPQueryException($"Exception in LDAP loop for {ldapFilter} and {domainName}", e); |
-| | | 912 | | |
-| | 0 | 913 | | yield break; |
-| | | 914 | | } |
-| | | 915 | | |
-| | 0 | 916 | | if (cancellationToken.IsCancellationRequested) |
-| | 0 | 917 | | yield break; |
-| | | 918 | | |
-| | 0 | 919 | | if (response == null || pageResponse == null) |
-| | 0 | 920 | | continue; |
-| | | 921 | | |
-| | 0 | 922 | | foreach (SearchResultEntry entry in response.Entries) |
-| | 0 | 923 | | { |
-| | 0 | 924 | | if (cancellationToken.IsCancellationRequested) |
-| | 0 | 925 | | yield break; |
-| | | 926 | | |
-| | 0 | 927 | | yield return new SearchResultEntryWrapper(entry, this); |
-| | 0 | 928 | | } |
-| | | 929 | | |
-| | 0 | 930 | | if (pageResponse.Cookie.Length == 0 || response.Entries.Count == 0 || |
-| | 0 | 931 | | cancellationToken.IsCancellationRequested) |
-| | 0 | 932 | | yield break; |
-| | | 933 | | |
-| | 0 | 934 | | pageControl.Cookie = pageResponse.Cookie; |
-| | 0 | 935 | | } |
-| | | 936 | | } |
-| | | 937 | | |
-| | | 938 | | private LdapConnection CreateNewConnection(string domainName = null, bool globalCatalog = false, bool skipCache |
-| | 0 | 939 | | { |
-| | 0 | 940 | | var task = globalCatalog |
-| | 0 | 941 | | ? Task.Run(() => CreateGlobalCatalogConnection(domainName, _ldapConfig.AuthType)) |
-| | 0 | 942 | | : Task.Run(() => CreateLDAPConnection(domainName, skipCache, _ldapConfig.AuthType)); |
-| | | 943 | | |
-| | | 944 | | try |
-| | 0 | 945 | | { |
-| | 0 | 946 | | return task.ConfigureAwait(false).GetAwaiter().GetResult(); |
-| | | 947 | | } |
-| | 0 | 948 | | catch |
-| | 0 | 949 | | { |
-| | 0 | 950 | | return null; |
-| | | 951 | | } |
-| | 0 | 952 | | } |
-| | | 953 | | |
-| | | 954 | | /// <summary> |
-| | | 955 | | /// Performs an LDAP query using the parameters specified by the user. |
-| | | 956 | | /// </summary> |
-| | | 957 | | /// <param name="ldapFilter">LDAP filter</param> |
-| | | 958 | | /// <param name="scope">SearchScope to query</param> |
-| | | 959 | | /// <param name="props">LDAP properties to fetch for each object</param> |
-| | | 960 | | /// <param name="includeAcl">Include the DACL and Owner values in the NTSecurityDescriptor</param> |
-| | | 961 | | /// <param name="showDeleted">Include deleted objects</param> |
-| | | 962 | | /// <param name="domainName">Domain to query</param> |
-| | | 963 | | /// <param name="adsPath">ADS path to limit the query too</param> |
-| | | 964 | | /// <param name="globalCatalog">Use the global catalog instead of the regular LDAP server</param> |
-| | | 965 | | /// <param name="skipCache"> |
-| | | 966 | | /// Skip the connection cache and force a new connection. You must dispose of this connection |
-| | | 967 | | /// yourself. |
-| | | 968 | | /// </param> |
-| | | 969 | | /// <param name="throwException">Throw exceptions rather than logging the errors directly</param> |
-| | | 970 | | /// <returns>All LDAP search results matching the specified parameters</returns> |
-| | | 971 | | /// <exception cref="LDAPQueryException"> |
-| | | 972 | | /// Thrown when an error occurs during LDAP query (only when throwException = true) |
-| | | 973 | | /// </exception> |
-| | | 974 | | public virtual IEnumerable<ISearchResultEntry> QueryLDAP(string ldapFilter, SearchScope scope, |
-| | | 975 | | string[] props, string domainName = null, bool includeAcl = false, bool showDeleted = false, |
-| | | 976 | | string adsPath = null, bool globalCatalog = false, bool skipCache = false, bool throwException = false) |
-| | 1 | 977 | | { |
-| | 1 | 978 | | var queryParams = SetupLDAPQueryFilter( |
-| | 1 | 979 | | ldapFilter, scope, props, includeAcl, domainName, includeAcl, adsPath, globalCatalog, skipCache); |
-| | | 980 | | |
-| | 1 | 981 | | if (queryParams.Exception != null) |
-| | 1 | 982 | | { |
-| | 1 | 983 | | if (throwException) throw queryParams.Exception; |
-| | | 984 | | |
-| | 1 | 985 | | _log.LogWarning(queryParams.Exception, "Failed to setup LDAP Query Filter"); |
-| | 1 | 986 | | yield break; |
-| | | 987 | | } |
-| | 0 | 988 | | var conn = queryParams.Connection; |
-| | 0 | 989 | | var request = queryParams.SearchRequest; |
-| | 0 | 990 | | var pageControl = queryParams.PageControl; |
-| | | 991 | | |
-| | 0 | 992 | | PageResultResponseControl pageResponse = null; |
+| | 0 | 792 | | type = result.GetLabel(); |
+| | | 793 | | |
+| | 0 | 794 | | Cache.AddConvertedValue(dn, id); |
+| | 0 | 795 | | Cache.AddType(id, type); |
+| | | 796 | | |
+| | 0 | 797 | | id = ConvertWellKnownPrincipal(id, domain); |
+| | | 798 | | |
+| | 0 | 799 | | return new TypedPrincipal |
+| | 0 | 800 | | { |
+| | 0 | 801 | | ObjectIdentifier = id, |
+| | 0 | 802 | | ObjectType = type |
+| | 0 | 803 | | }; |
+| | 0 | 804 | | } |
+| | | 805 | | |
+| | | 806 | | /// <summary> |
+| | | 807 | | /// Queries LDAP using LDAPQueryOptions |
+| | | 808 | | /// </summary> |
+| | | 809 | | /// <param name="options"></param> |
+| | | 810 | | /// <returns></returns> |
+| | | 811 | | public IEnumerable<ISearchResultEntry> QueryLDAP(LDAPQueryOptions options) |
+| | 2 | 812 | | { |
+| | 2 | 813 | | return QueryLDAP( |
+| | 2 | 814 | | options.Filter, |
+| | 2 | 815 | | options.Scope, |
+| | 2 | 816 | | options.Properties, |
+| | 2 | 817 | | options.CancellationToken, |
+| | 2 | 818 | | options.DomainName, |
+| | 2 | 819 | | options.IncludeAcl, |
+| | 2 | 820 | | options.ShowDeleted, |
+| | 2 | 821 | | options.AdsPath, |
+| | 2 | 822 | | options.GlobalCatalog, |
+| | 2 | 823 | | options.SkipCache, |
+| | 2 | 824 | | options.ThrowException |
+| | 2 | 825 | | ); |
+| | 2 | 826 | | } |
+| | | 827 | | |
+| | | 828 | | /// <summary> |
+| | | 829 | | /// Performs an LDAP query using the parameters specified by the user. |
+| | | 830 | | /// </summary> |
+| | | 831 | | /// <param name="ldapFilter">LDAP filter</param> |
+| | | 832 | | /// <param name="scope">SearchScope to query</param> |
+| | | 833 | | /// <param name="props">LDAP properties to fetch for each object</param> |
+| | | 834 | | /// <param name="cancellationToken">Cancellation Token</param> |
+| | | 835 | | /// <param name="includeAcl">Include the DACL and Owner values in the NTSecurityDescriptor</param> |
+| | | 836 | | /// <param name="showDeleted">Include deleted objects</param> |
+| | | 837 | | /// <param name="domainName">Domain to query</param> |
+| | | 838 | | /// <param name="adsPath">ADS path to limit the query too</param> |
+| | | 839 | | /// <param name="globalCatalog">Use the global catalog instead of the regular LDAP server</param> |
+| | | 840 | | /// <param name="skipCache"> |
+| | | 841 | | /// Skip the connection cache and force a new connection. You must dispose of this connection |
+| | | 842 | | /// yourself. |
+| | | 843 | | /// </param> |
+| | | 844 | | /// <param name="throwException">Throw exceptions rather than logging the errors directly</param> |
+| | | 845 | | /// <returns>All LDAP search results matching the specified parameters</returns> |
+| | | 846 | | /// <exception cref="LDAPQueryException"> |
+| | | 847 | | /// Thrown when an error occurs during LDAP query (only when throwException = true) |
+| | | 848 | | /// </exception> |
+| | | 849 | | public IEnumerable<ISearchResultEntry> QueryLDAP(string ldapFilter, SearchScope scope, |
+| | | 850 | | string[] props, CancellationToken cancellationToken, string domainName = null, bool includeAcl = false, |
+| | | 851 | | bool showDeleted = false, string adsPath = null, bool globalCatalog = false, bool skipCache = false, |
+| | | 852 | | bool throwException = false) |
+| | 5 | 853 | | { |
+| | 5 | 854 | | var queryParams = SetupLDAPQueryFilter( |
+| | 5 | 855 | | ldapFilter, scope, props, includeAcl, domainName, includeAcl, adsPath, globalCatalog, skipCache); |
+| | | 856 | | |
+| | 5 | 857 | | if (queryParams.Exception != null) |
+| | 5 | 858 | | { |
+| | 5 | 859 | | _log.LogWarning("Failed to setup LDAP Query Filter: {Message}", queryParams.Exception.Message); |
+| | 5 | 860 | | if (throwException) |
+| | 2 | 861 | | throw new LDAPQueryException("Failed to setup LDAP Query Filter", queryParams.Exception); |
+| | 3 | 862 | | yield break; |
+| | | 863 | | } |
+| | | 864 | | |
+| | 0 | 865 | | var conn = queryParams.Connection; |
+| | 0 | 866 | | var request = queryParams.SearchRequest; |
+| | 0 | 867 | | var pageControl = queryParams.PageControl; |
+| | | 868 | | |
+| | 0 | 869 | | PageResultResponseControl pageResponse = null; |
+| | 0 | 870 | | var backoffDelay = MinBackoffDelay; |
+| | 0 | 871 | | var retryCount = 0; |
+| | 0 | 872 | | while (true) |
+| | 0 | 873 | | { |
+| | 0 | 874 | | if (cancellationToken.IsCancellationRequested) |
+| | 0 | 875 | | yield break; |
+| | | 876 | | |
+| | | 877 | | SearchResponse response; |
+| | | 878 | | try |
+| | 0 | 879 | | { |
+| | 0 | 880 | | _log.LogTrace("Sending LDAP request for {Filter}", ldapFilter); |
+| | 0 | 881 | | response = (SearchResponse)conn.SendRequest(request); |
+| | 0 | 882 | | if (response != null) |
+| | 0 | 883 | | pageResponse = (PageResultResponseControl)response.Controls |
+| | 0 | 884 | | .Where(x => x is PageResultResponseControl).DefaultIfEmpty(null).FirstOrDefault(); |
+| | 0 | 885 | | } |
+| | 0 | 886 | | catch (LdapException le) when (le.ErrorCode == (int)LdapErrorCodes.ServerDown && |
+| | 0 | 887 | | retryCount < MaxRetries) |
+| | 0 | 888 | | { |
+| | | 889 | | /*A ServerDown exception indicates that our connection is no longer valid for one of many reasons. |
+| | | 890 | | However, this function is generally called by multiple threads, so we need to be careful in recreati |
+| | | 891 | | the connection. Using a semaphore, we can ensure that only one thread is actually recreating the con |
+| | | 892 | | while the other threads that hit the ServerDown exception simply wait. The initial caller will hold |
+| | | 893 | | and do a backoff delay before trying to make a new connection which will replace the existing connec |
+| | | 894 | | _ldapConnections cache. Other threads will retrieve the new connection from the cache instead of mak |
+| | | 895 | | This minimizes overhead of new connections while still fixing our core problem.*/ |
+| | | 896 | | |
+| | | 897 | | //Always increment retry count |
+| | 0 | 898 | | retryCount++; |
+| | | 899 | | |
+| | | 900 | | //Attempt to acquire a lock |
+| | 0 | 901 | | if (Monitor.TryEnter(_lockObj)) |
+| | 0 | 902 | | { |
+| | | 903 | | //If we've acquired the lock, we want to immediately signal our reset event so everyone else wai |
+| | 0 | 904 | | _connectionResetEvent.Reset(); |
+| | | 905 | | try |
+| | 0 | 906 | | { |
+| | | 907 | | //Sleep for our backoff |
+| | 0 | 908 | | Thread.Sleep(backoffDelay); |
+| | | 909 | | //Explicitly skip the cache so we don't get the same connection back |
+| | 0 | 910 | | conn = CreateNewConnection(domainName, globalCatalog, true); |
+| | 0 | 911 | | if (conn == null) |
+| | 0 | 912 | | { |
+| | 0 | 913 | | _log.LogError( |
+| | 0 | 914 | | "Unable to create replacement ldap connection for ServerDown exception. Breaking loo |
+| | 0 | 915 | | yield break; |
+| | | 916 | | } |
+| | | 917 | | |
+| | 0 | 918 | | _log.LogInformation("Created new LDAP connection after receiving ServerDown from server"); |
+| | 0 | 919 | | } |
+| | | 920 | | finally |
+| | 0 | 921 | | { |
+| | | 922 | | //Reset our event + release the lock |
+| | 0 | 923 | | _connectionResetEvent.Set(); |
+| | 0 | 924 | | Monitor.Exit(_lockObj); |
+| | 0 | 925 | | } |
+| | 0 | 926 | | } |
+| | | 927 | | else |
+| | 0 | 928 | | { |
+| | | 929 | | //If someone else is holding the reset event, we want to just wait and then pull the newly creat |
+| | | 930 | | //This event will be released after the first entrant thread is done making a new connection |
+| | | 931 | | //The thread.sleep is to prevent a potential, very unlikely race |
+| | 0 | 932 | | Thread.Sleep(50); |
+| | 0 | 933 | | _connectionResetEvent.WaitOne(); |
+| | 0 | 934 | | conn = CreateNewConnection(domainName, globalCatalog); |
+| | 0 | 935 | | } |
+| | | 936 | | |
+| | 0 | 937 | | backoffDelay = GetNextBackoff(retryCount); |
+| | 0 | 938 | | continue; |
+| | | 939 | | } |
+| | 0 | 940 | | catch (LdapException le) when (le.ErrorCode == (int)LdapErrorCodes.Busy && retryCount < MaxRetries) |
+| | 0 | 941 | | { |
+| | 0 | 942 | | retryCount++; |
+| | 0 | 943 | | backoffDelay = GetNextBackoff(retryCount); |
+| | 0 | 944 | | continue; |
+| | | 945 | | } |
+| | 0 | 946 | | catch (LdapException le) |
+| | 0 | 947 | | { |
+| | 0 | 948 | | if (le.ErrorCode != (int)LdapErrorCodes.LocalError) |
+| | 0 | 949 | | { |
+| | 0 | 950 | | if (throwException) |
+| | 0 | 951 | | { |
+| | 0 | 952 | | throw new LDAPQueryException( |
+| | 0 | 953 | | $"LDAP Exception in Loop: {le.ErrorCode}. {le.ServerErrorMessage}. {le.Message}. Filter: |
+| | 0 | 954 | | le); |
+| | | 955 | | } |
+| | | 956 | | |
+| | 0 | 957 | | _log.LogWarning(le, |
+| | 0 | 958 | | "LDAP Exception in Loop: {ErrorCode}. {ServerErrorMessage}. {Message}. Filter: {Filter}. Dom |
+| | 0 | 959 | | le.ErrorCode, le.ServerErrorMessage, le.Message, ldapFilter, domainName); |
+| | 0 | 960 | | } |
+| | | 961 | | |
+| | 0 | 962 | | if (le.ErrorCode == (int)LdapErrorCodes.ServerDown) |
+| | 0 | 963 | | { |
+| | 0 | 964 | | throw new LDAPQueryException( |
+| | 0 | 965 | | $"LDAP Exception in Loop: {le.ErrorCode}. {le.ServerErrorMessage}. {le.Message}. Filter: {ld |
+| | 0 | 966 | | le); |
+| | | 967 | | } |
+| | | 968 | | |
+| | 0 | 969 | | yield break; |
+| | | 970 | | } |
+| | 0 | 971 | | catch (Exception e) |
+| | 0 | 972 | | { |
+| | 0 | 973 | | _log.LogWarning(e, "Exception in LDAP loop for {Filter} and {Domain}", ldapFilter, domainName); |
+| | 0 | 974 | | if (throwException) |
+| | 0 | 975 | | throw new LDAPQueryException($"Exception in LDAP loop for {ldapFilter} and {domainName}", e); |
+| | | 976 | | |
+| | 0 | 977 | | yield break; |
+| | | 978 | | } |
+| | | 979 | | |
+| | 0 | 980 | | if (cancellationToken.IsCancellationRequested) |
+| | 0 | 981 | | yield break; |
+| | | 982 | | |
+| | 0 | 983 | | if (response == null || pageResponse == null) |
+| | 0 | 984 | | continue; |
+| | | 985 | | |
+| | 0 | 986 | | foreach (SearchResultEntry entry in response.Entries) |
+| | 0 | 987 | | { |
+| | 0 | 988 | | if (cancellationToken.IsCancellationRequested) |
+| | 0 | 989 | | yield break; |
+| | | 990 | | |
+| | 0 | 991 | | yield return new SearchResultEntryWrapper(entry, this); |
+| | 0 | 992 | | } |
| | | 993 | | |
-| | 0 | 994 | | var backoffDelay = MinBackoffDelay; |
-| | 0 | 995 | | var retryCount = 0; |
-| | | 996 | | |
-| | 0 | 997 | | while (true) |
-| | 0 | 998 | | { |
-| | | 999 | | SearchResponse response; |
-| | | 1000 | | |
-| | | 1001 | | try |
-| | 0 | 1002 | | { |
-| | 0 | 1003 | | _log.LogTrace("Sending LDAP request for {Filter}", ldapFilter); |
-| | 0 | 1004 | | response = (SearchResponse)conn.SendRequest(request); |
-| | 0 | 1005 | | if (response != null) |
-| | 0 | 1006 | | pageResponse = (PageResultResponseControl)response.Controls |
-| | 0 | 1007 | | .Where(x => x is PageResultResponseControl).DefaultIfEmpty(null).FirstOrDefault(); |
-| | 0 | 1008 | | } |
-| | 0 | 1009 | | catch (LdapException le) when (le.ErrorCode == (int)LdapErrorCodes.Busy && retryCount < MaxRetries) |
-| | 0 | 1010 | | { |
-| | 0 | 1011 | | retryCount++; |
-| | 0 | 1012 | | Thread.Sleep(backoffDelay); |
-| | 0 | 1013 | | backoffDelay = TimeSpan.FromSeconds(Math.Min( |
-| | 0 | 1014 | | backoffDelay.TotalSeconds * BackoffDelayMultiplier.TotalSeconds, MaxBackoffDelay.TotalSeconds)); |
-| | 0 | 1015 | | continue; |
-| | | 1016 | | } |
-| | 0 | 1017 | | catch (LdapException le) when (le.ErrorCode == (int)LdapErrorCodes.ServerDown && |
-| | 0 | 1018 | | retryCount < MaxRetries) |
-| | 0 | 1019 | | { |
-| | 0 | 1020 | | retryCount++; |
-| | 0 | 1021 | | Thread.Sleep(backoffDelay); |
-| | 0 | 1022 | | backoffDelay = TimeSpan.FromSeconds(Math.Min( |
-| | 0 | 1023 | | backoffDelay.TotalSeconds * BackoffDelayMultiplier.TotalSeconds, MaxBackoffDelay.TotalSeconds)); |
-| | 0 | 1024 | | conn = CreateNewConnection(domainName, globalCatalog, skipCache); |
-| | 0 | 1025 | | if (conn == null) |
-| | 0 | 1026 | | { |
-| | 0 | 1027 | | _log.LogError("Unable to create replacement ldap connection for ServerDown exception. Breaking l |
-| | 0 | 1028 | | yield break; |
-| | | 1029 | | } |
-| | | 1030 | | |
-| | 0 | 1031 | | _log.LogInformation("Created new LDAP connection after receiving ServerDown from server"); |
-| | 0 | 1032 | | continue; |
-| | | 1033 | | } |
-| | 0 | 1034 | | catch (LdapException le) |
-| | 0 | 1035 | | { |
-| | 0 | 1036 | | if (le.ErrorCode != 82) |
-| | 0 | 1037 | | if (throwException) |
-| | 0 | 1038 | | throw new LDAPQueryException( |
-| | 0 | 1039 | | $"LDAP Exception in Loop: {le.ErrorCode}. {le.ServerErrorMessage}. {le.Message}. Filter: |
-| | 0 | 1040 | | le); |
-| | | 1041 | | else |
-| | 0 | 1042 | | _log.LogWarning(le, |
-| | 0 | 1043 | | "LDAP Exception in Loop: {ErrorCode}. {ServerErrorMessage}. {Message}. Filter: {Filter}. |
-| | 0 | 1044 | | le.ErrorCode, le.ServerErrorMessage, le.Message, ldapFilter, domainName); |
-| | 0 | 1045 | | yield break; |
-| | | 1046 | | } |
-| | 0 | 1047 | | catch (Exception e) |
-| | 0 | 1048 | | { |
-| | 0 | 1049 | | if (throwException) |
-| | 0 | 1050 | | throw new LDAPQueryException( |
-| | 0 | 1051 | | $"Exception in LDAP loop for {ldapFilter} and {domainName ?? "Default Domain"}", e); |
-| | | 1052 | | |
-| | 0 | 1053 | | _log.LogWarning(e, "Exception in LDAP loop for {Filter} and {Domain}", ldapFilter, |
-| | 0 | 1054 | | domainName ?? "Default Domain"); |
-| | 0 | 1055 | | yield break; |
-| | | 1056 | | } |
-| | | 1057 | | |
-| | 0 | 1058 | | if (response == null || pageResponse == null) continue; |
-| | | 1059 | | |
-| | 0 | 1060 | | if (response.Entries == null) |
-| | 0 | 1061 | | yield break; |
-| | | 1062 | | |
-| | 0 | 1063 | | foreach (SearchResultEntry entry in response.Entries) |
-| | 0 | 1064 | | yield return new SearchResultEntryWrapper(entry, this); |
-| | | 1065 | | |
-| | 0 | 1066 | | if (pageResponse.Cookie.Length == 0 || response.Entries.Count == 0) |
-| | 0 | 1067 | | yield break; |
-| | | 1068 | | |
-| | 0 | 1069 | | pageControl.Cookie = pageResponse.Cookie; |
-| | 0 | 1070 | | } |
-| | | 1071 | | } |
-| | | 1072 | | |
-| | | 1073 | | /// <summary> |
-| | | 1074 | | /// Gets the forest associated with a domain. |
-| | | 1075 | | /// If no domain is provided, defaults to current domain |
-| | | 1076 | | /// </summary> |
-| | | 1077 | | /// <param name="domainName"></param> |
-| | | 1078 | | /// <returns></returns> |
-| | | 1079 | | public virtual Forest GetForest(string domainName = null) |
-| | 35 | 1080 | | { |
-| | | 1081 | | try |
-| | 35 | 1082 | | { |
-| | 35 | 1083 | | if (domainName == null && _ldapConfig.Username == null) |
-| | 35 | 1084 | | return Forest.GetCurrentForest(); |
+| | 0 | 994 | | if (pageResponse.Cookie.Length == 0 || response.Entries.Count == 0 || |
+| | 0 | 995 | | cancellationToken.IsCancellationRequested) |
+| | 0 | 996 | | yield break; |
+| | | 997 | | |
+| | 0 | 998 | | pageControl.Cookie = pageResponse.Cookie; |
+| | 0 | 999 | | } |
+| | | 1000 | | } |
+| | | 1001 | | |
+| | | 1002 | | private LdapConnection CreateNewConnection(string domainName = null, bool globalCatalog = false, |
+| | | 1003 | | bool skipCache = false) |
+| | 0 | 1004 | | { |
+| | 0 | 1005 | | var task = globalCatalog |
+| | 0 | 1006 | | ? Task.Run(() => CreateGlobalCatalogConnection(domainName, _ldapConfig.AuthType)) |
+| | 0 | 1007 | | : Task.Run(() => CreateLDAPConnection(domainName, skipCache, _ldapConfig.AuthType)); |
+| | | 1008 | | |
+| | | 1009 | | try |
+| | 0 | 1010 | | { |
+| | 0 | 1011 | | return task.ConfigureAwait(false).GetAwaiter().GetResult(); |
+| | | 1012 | | } |
+| | 0 | 1013 | | catch |
+| | 0 | 1014 | | { |
+| | 0 | 1015 | | return null; |
+| | | 1016 | | } |
+| | 0 | 1017 | | } |
+| | | 1018 | | |
+| | | 1019 | | /// <summary> |
+| | | 1020 | | /// Performs an LDAP query using the parameters specified by the user. |
+| | | 1021 | | /// </summary> |
+| | | 1022 | | /// <param name="ldapFilter">LDAP filter</param> |
+| | | 1023 | | /// <param name="scope">SearchScope to query</param> |
+| | | 1024 | | /// <param name="props">LDAP properties to fetch for each object</param> |
+| | | 1025 | | /// <param name="includeAcl">Include the DACL and Owner values in the NTSecurityDescriptor</param> |
+| | | 1026 | | /// <param name="showDeleted">Include deleted objects</param> |
+| | | 1027 | | /// <param name="domainName">Domain to query</param> |
+| | | 1028 | | /// <param name="adsPath">ADS path to limit the query too</param> |
+| | | 1029 | | /// <param name="globalCatalog">Use the global catalog instead of the regular LDAP server</param> |
+| | | 1030 | | /// <param name="skipCache"> |
+| | | 1031 | | /// Skip the connection cache and force a new connection. You must dispose of this connection |
+| | | 1032 | | /// yourself. |
+| | | 1033 | | /// </param> |
+| | | 1034 | | /// <param name="throwException">Throw exceptions rather than logging the errors directly</param> |
+| | | 1035 | | /// <returns>All LDAP search results matching the specified parameters</returns> |
+| | | 1036 | | /// <exception cref="LDAPQueryException"> |
+| | | 1037 | | /// Thrown when an error occurs during LDAP query (only when throwException = true) |
+| | | 1038 | | /// </exception> |
+| | | 1039 | | public virtual IEnumerable<ISearchResultEntry> QueryLDAP(string ldapFilter, SearchScope scope, |
+| | | 1040 | | string[] props, string domainName = null, bool includeAcl = false, bool showDeleted = false, |
+| | | 1041 | | string adsPath = null, bool globalCatalog = false, bool skipCache = false, bool throwException = false) |
+| | 1 | 1042 | | { |
+| | 1 | 1043 | | return QueryLDAP(ldapFilter, scope, props, new CancellationToken(), domainName, includeAcl, showDeleted, |
+| | 1 | 1044 | | adsPath, globalCatalog, skipCache, throwException); |
+| | 1 | 1045 | | } |
+| | | 1046 | | |
+| | | 1047 | | private static TimeSpan GetNextBackoff(int retryCount) |
+| | 0 | 1048 | | { |
+| | 0 | 1049 | | return TimeSpan.FromSeconds(Math.Min( |
+| | 0 | 1050 | | MinBackoffDelay.TotalSeconds * Math.Pow(BackoffDelayMultiplier, retryCount), |
+| | 0 | 1051 | | MaxBackoffDelay.TotalSeconds)); |
+| | 0 | 1052 | | } |
+| | | 1053 | | |
+| | | 1054 | | /// <summary> |
+| | | 1055 | | /// Gets the forest associated with a domain. |
+| | | 1056 | | /// If no domain is provided, defaults to current domain |
+| | | 1057 | | /// </summary> |
+| | | 1058 | | /// <param name="domainName"></param> |
+| | | 1059 | | /// <returns></returns> |
+| | | 1060 | | public virtual Forest GetForest(string domainName = null) |
+| | 35 | 1061 | | { |
+| | | 1062 | | try |
+| | 35 | 1063 | | { |
+| | 35 | 1064 | | if (domainName == null && _ldapConfig.Username == null) |
+| | 35 | 1065 | | return Forest.GetCurrentForest(); |
+| | | 1066 | | |
+| | 0 | 1067 | | var domain = GetDomain(domainName); |
+| | 0 | 1068 | | return domain?.Forest; |
+| | | 1069 | | } |
+| | 35 | 1070 | | catch |
+| | 35 | 1071 | | { |
+| | 35 | 1072 | | return null; |
+| | | 1073 | | } |
+| | 35 | 1074 | | } |
+| | | 1075 | | |
+| | | 1076 | | /// <summary> |
+| | | 1077 | | /// Creates a new ActiveDirectorySecurityDescriptor |
+| | | 1078 | | /// Function created for testing purposes |
+| | | 1079 | | /// </summary> |
+| | | 1080 | | /// <returns></returns> |
+| | | 1081 | | public ActiveDirectorySecurityDescriptor MakeSecurityDescriptor() |
+| | 0 | 1082 | | { |
+| | 0 | 1083 | | return new ActiveDirectorySecurityDescriptor(new ActiveDirectorySecurity()); |
+| | 0 | 1084 | | } |
| | | 1085 | | |
-| | 0 | 1086 | | var domain = GetDomain(domainName); |
-| | 0 | 1087 | | return domain?.Forest; |
-| | | 1088 | | } |
-| | 35 | 1089 | | catch |
-| | 35 | 1090 | | { |
-| | 35 | 1091 | | return null; |
-| | | 1092 | | } |
-| | 35 | 1093 | | } |
-| | | 1094 | | |
-| | | 1095 | | /// <summary> |
-| | | 1096 | | /// Creates a new ActiveDirectorySecurityDescriptor |
-| | | 1097 | | /// Function created for testing purposes |
+| | | 1086 | | public string BuildLdapPath(string dnPath, string domainName) |
+| | 2 | 1087 | | { |
+| | 2 | 1088 | | var domain = GetDomain(domainName)?.Name; |
+| | 2 | 1089 | | if (domain == null) |
+| | 1 | 1090 | | return null; |
+| | | 1091 | | |
+| | 1 | 1092 | | var adPath = $"{dnPath},DC={domain.Replace(".", ",DC=")}"; |
+| | 1 | 1093 | | return adPath; |
+| | 2 | 1094 | | } |
+| | | 1095 | | |
+| | | 1096 | | /// <summary> |
+| | | 1097 | | /// Tests the current LDAP config to ensure its valid by pulling a domain object |
| | | 1098 | | /// </summary> |
-| | | 1099 | | /// <returns></returns> |
-| | | 1100 | | public ActiveDirectorySecurityDescriptor MakeSecurityDescriptor() |
+| | | 1099 | | /// <returns>True if connection was successful, else false</returns> |
+| | | 1100 | | public bool TestLDAPConfig(string domain) |
| | 0 | 1101 | | { |
-| | 0 | 1102 | | return new ActiveDirectorySecurityDescriptor(new ActiveDirectorySecurity()); |
-| | 0 | 1103 | | } |
+| | 0 | 1102 | | var filter = new LDAPFilter(); |
+| | 0 | 1103 | | filter.AddDomains(); |
| | | 1104 | | |
-| | | 1105 | | public string BuildLdapPath(string dnPath, string domainName) |
-| | 2 | 1106 | | { |
-| | 2 | 1107 | | var domain = GetDomain(domainName)?.Name; |
-| | 2 | 1108 | | if (domain == null) |
-| | 1 | 1109 | | return null; |
-| | | 1110 | | |
-| | 1 | 1111 | | var adPath = $"{dnPath},DC={domain.Replace(".", ",DC=")}"; |
-| | 1 | 1112 | | return adPath; |
-| | 2 | 1113 | | } |
+| | 0 | 1105 | | var resDomain = GetDomain(domain)?.Name ?? domain; |
+| | 0 | 1106 | | _log.LogTrace("Testing LDAP connection for domain {Domain}", resDomain); |
+| | | 1107 | | |
+| | 0 | 1108 | | var result = QueryLDAP(filter.GetFilter(), SearchScope.Subtree, CommonProperties.ObjectID, resDomain, |
+| | 0 | 1109 | | throwException: true) |
+| | 0 | 1110 | | .DefaultIfEmpty(null).FirstOrDefault(); |
+| | 0 | 1111 | | _log.LogTrace("Result object from LDAP connection test is {DN}", result?.DistinguishedName ?? "null"); |
+| | 0 | 1112 | | return result != null; |
+| | 0 | 1113 | | } |
| | | 1114 | | |
| | | 1115 | | /// <summary> |
-| | | 1116 | | /// Tests the current LDAP config to ensure its valid by pulling a domain object |
-| | | 1117 | | /// </summary> |
-| | | 1118 | | /// <returns>True if connection was successful, else false</returns> |
-| | | 1119 | | public bool TestLDAPConfig(string domain) |
-| | 0 | 1120 | | { |
-| | 0 | 1121 | | var filter = new LDAPFilter(); |
-| | 0 | 1122 | | filter.AddDomains(); |
-| | | 1123 | | |
-| | 0 | 1124 | | var resDomain = GetDomain(domain)?.Name ?? domain; |
-| | 0 | 1125 | | _log.LogTrace("Testing LDAP connection for domain {Domain}", resDomain); |
-| | | 1126 | | |
-| | 0 | 1127 | | var result = QueryLDAP(filter.GetFilter(), SearchScope.Subtree, CommonProperties.ObjectID, resDomain, |
-| | 0 | 1128 | | throwException: true) |
-| | 0 | 1129 | | .DefaultIfEmpty(null).FirstOrDefault(); |
-| | 0 | 1130 | | _log.LogTrace("Result object from LDAP connection test is {DN}", result?.DistinguishedName ?? "null"); |
-| | 0 | 1131 | | return result != null; |
-| | 0 | 1132 | | } |
-| | | 1133 | | |
-| | | 1134 | | /// <summary> |
-| | | 1135 | | /// Gets the domain object associated with the specified domain name. |
-| | | 1136 | | /// Defaults to current domain if none specified |
-| | | 1137 | | /// </summary> |
-| | | 1138 | | /// <param name="domainName"></param> |
-| | | 1139 | | /// <returns></returns> |
-| | | 1140 | | public virtual Domain GetDomain(string domainName = null) |
-| | 5 | 1141 | | { |
-| | 5 | 1142 | | var cacheKey = domainName ?? NullCacheKey; |
-| | 7 | 1143 | | if (_domainCache.TryGetValue(cacheKey, out var domain)) return domain; |
-| | | 1144 | | |
-| | | 1145 | | try |
-| | 3 | 1146 | | { |
-| | | 1147 | | DirectoryContext context; |
-| | 3 | 1148 | | if (_ldapConfig.Username != null) |
-| | 0 | 1149 | | context = domainName != null |
-| | 0 | 1150 | | ? new DirectoryContext(DirectoryContextType.Domain, domainName, _ldapConfig.Username, |
-| | 0 | 1151 | | _ldapConfig.Password) |
-| | 0 | 1152 | | : new DirectoryContext(DirectoryContextType.Domain, _ldapConfig.Username, |
-| | 0 | 1153 | | _ldapConfig.Password); |
-| | | 1154 | | else |
-| | 3 | 1155 | | context = domainName != null |
-| | 3 | 1156 | | ? new DirectoryContext(DirectoryContextType.Domain, domainName) |
-| | 3 | 1157 | | : new DirectoryContext(DirectoryContextType.Domain); |
-| | | 1158 | | |
-| | 3 | 1159 | | domain = Domain.GetDomain(context); |
-| | 0 | 1160 | | } |
-| | 3 | 1161 | | catch (Exception e) |
-| | 3 | 1162 | | { |
-| | 3 | 1163 | | _log.LogDebug(e, "GetDomain call failed at {StackTrace}", new StackFrame()); |
-| | 3 | 1164 | | domain = null; |
-| | 3 | 1165 | | } |
-| | | 1166 | | |
-| | 3 | 1167 | | _domainCache.TryAdd(cacheKey, domain); |
-| | 3 | 1168 | | return domain; |
-| | 5 | 1169 | | } |
-| | | 1170 | | |
-| | | 1171 | | /// <summary> |
-| | | 1172 | | /// Setup LDAP query for filter |
-| | | 1173 | | /// </summary> |
-| | | 1174 | | /// <param name="ldapFilter">LDAP filter</param> |
-| | | 1175 | | /// <param name="scope">SearchScope to query</param> |
-| | | 1176 | | /// <param name="props">LDAP properties to fetch for each object</param> |
-| | | 1177 | | /// <param name="includeAcl">Include the DACL and Owner values in the NTSecurityDescriptor</param> |
-| | | 1178 | | /// <param name="domainName">Domain to query</param> |
-| | | 1179 | | /// <param name="showDeleted">Include deleted objects</param> |
-| | | 1180 | | /// <param name="adsPath">ADS path to limit the query too</param> |
-| | | 1181 | | /// <param name="globalCatalog">Use the global catalog instead of the regular LDAP server</param> |
-| | | 1182 | | /// <param name="skipCache"> |
-| | | 1183 | | /// Skip the connection cache and force a new connection. You must dispose of this connection |
-| | | 1184 | | /// yourself. |
-| | | 1185 | | /// </param> |
-| | | 1186 | | /// <returns>Tuple of LdapConnection, SearchRequest, PageResultRequestControl and LDAPQueryException</returns> |
-| | | 1187 | | // ReSharper disable once MemberCanBePrivate.Global |
-| | | 1188 | | internal LDAPQueryParams SetupLDAPQueryFilter( |
-| | | 1189 | | string ldapFilter, |
-| | | 1190 | | SearchScope scope, string[] props, bool includeAcl = false, string domainName = null, |
-| | | 1191 | | bool showDeleted = false, |
-| | | 1192 | | string adsPath = null, bool globalCatalog = false, bool skipCache = false) |
-| | 5 | 1193 | | { |
-| | 5 | 1194 | | _log.LogTrace("Creating ldap connection for {Target} with filter {Filter}", |
-| | 5 | 1195 | | globalCatalog ? "Global Catalog" : "DC", ldapFilter); |
-| | 5 | 1196 | | var task = globalCatalog |
-| | 1 | 1197 | | ? Task.Run(() => CreateGlobalCatalogConnection(domainName, _ldapConfig.AuthType)) |
-| | 9 | 1198 | | : Task.Run(() => CreateLDAPConnection(domainName, skipCache, _ldapConfig.AuthType)); |
-| | | 1199 | | |
-| | 5 | 1200 | | var queryParams = new LDAPQueryParams(); |
-| | | 1201 | | |
-| | | 1202 | | LdapConnection conn; |
-| | | 1203 | | try |
-| | 5 | 1204 | | { |
-| | 5 | 1205 | | conn = task.ConfigureAwait(false).GetAwaiter().GetResult(); |
-| | 0 | 1206 | | } |
-| | 0 | 1207 | | catch (LdapException ldapException) |
-| | 0 | 1208 | | { |
-| | 0 | 1209 | | var errorString = |
-| | 0 | 1210 | | $"LDAP Exception {ldapException.ErrorCode} when creating connection for {ldapFilter} and domain {dom |
-| | 0 | 1211 | | queryParams.Exception = new LDAPQueryException(errorString, ldapException); |
-| | 0 | 1212 | | return queryParams; |
-| | | 1213 | | } |
-| | 5 | 1214 | | catch (LDAPQueryException ldapQueryException) |
-| | 5 | 1215 | | { |
-| | 5 | 1216 | | queryParams.Exception = ldapQueryException; |
-| | 5 | 1217 | | return queryParams; |
-| | | 1218 | | } |
-| | 0 | 1219 | | catch (Exception e) |
+| | | 1116 | | /// Gets the domain object associated with the specified domain name. |
+| | | 1117 | | /// Defaults to current domain if none specified |
+| | | 1118 | | /// </summary> |
+| | | 1119 | | /// <param name="domainName"></param> |
+| | | 1120 | | /// <returns></returns> |
+| | | 1121 | | public virtual Domain GetDomain(string domainName = null) |
+| | 5 | 1122 | | { |
+| | 5 | 1123 | | var cacheKey = domainName ?? NullCacheKey; |
+| | 7 | 1124 | | if (_domainCache.TryGetValue(cacheKey, out var domain)) return domain; |
+| | | 1125 | | |
+| | | 1126 | | try |
+| | 3 | 1127 | | { |
+| | | 1128 | | DirectoryContext context; |
+| | 3 | 1129 | | if (_ldapConfig.Username != null) |
+| | 0 | 1130 | | context = domainName != null |
+| | 0 | 1131 | | ? new DirectoryContext(DirectoryContextType.Domain, domainName, _ldapConfig.Username, |
+| | 0 | 1132 | | _ldapConfig.Password) |
+| | 0 | 1133 | | : new DirectoryContext(DirectoryContextType.Domain, _ldapConfig.Username, |
+| | 0 | 1134 | | _ldapConfig.Password); |
+| | | 1135 | | else |
+| | 3 | 1136 | | context = domainName != null |
+| | 3 | 1137 | | ? new DirectoryContext(DirectoryContextType.Domain, domainName) |
+| | 3 | 1138 | | : new DirectoryContext(DirectoryContextType.Domain); |
+| | | 1139 | | |
+| | 3 | 1140 | | domain = Domain.GetDomain(context); |
+| | 0 | 1141 | | } |
+| | 3 | 1142 | | catch (Exception e) |
+| | 3 | 1143 | | { |
+| | 3 | 1144 | | _log.LogDebug(e, "GetDomain call failed at {StackTrace}", new StackFrame()); |
+| | 3 | 1145 | | domain = null; |
+| | 3 | 1146 | | } |
+| | | 1147 | | |
+| | 3 | 1148 | | _domainCache.TryAdd(cacheKey, domain); |
+| | 3 | 1149 | | return domain; |
+| | 5 | 1150 | | } |
+| | | 1151 | | |
+| | | 1152 | | /// <summary> |
+| | | 1153 | | /// Setup LDAP query for filter |
+| | | 1154 | | /// </summary> |
+| | | 1155 | | /// <param name="ldapFilter">LDAP filter</param> |
+| | | 1156 | | /// <param name="scope">SearchScope to query</param> |
+| | | 1157 | | /// <param name="props">LDAP properties to fetch for each object</param> |
+| | | 1158 | | /// <param name="includeAcl">Include the DACL and Owner values in the NTSecurityDescriptor</param> |
+| | | 1159 | | /// <param name="domainName">Domain to query</param> |
+| | | 1160 | | /// <param name="showDeleted">Include deleted objects</param> |
+| | | 1161 | | /// <param name="adsPath">ADS path to limit the query too</param> |
+| | | 1162 | | /// <param name="globalCatalog">Use the global catalog instead of the regular LDAP server</param> |
+| | | 1163 | | /// <param name="skipCache"> |
+| | | 1164 | | /// Skip the connection cache and force a new connection. You must dispose of this connection |
+| | | 1165 | | /// yourself. |
+| | | 1166 | | /// </param> |
+| | | 1167 | | /// <returns>Tuple of LdapConnection, SearchRequest, PageResultRequestControl and LDAPQueryException</returns> |
+| | | 1168 | | // ReSharper disable once MemberCanBePrivate.Global |
+| | | 1169 | | internal LDAPQueryParams SetupLDAPQueryFilter( |
+| | | 1170 | | string ldapFilter, |
+| | | 1171 | | SearchScope scope, string[] props, bool includeAcl = false, string domainName = null, |
+| | | 1172 | | bool showDeleted = false, |
+| | | 1173 | | string adsPath = null, bool globalCatalog = false, bool skipCache = false) |
+| | 5 | 1174 | | { |
+| | 5 | 1175 | | _log.LogTrace("Creating ldap connection for {Target} with filter {Filter}", |
+| | 5 | 1176 | | globalCatalog ? "Global Catalog" : "DC", ldapFilter); |
+| | 5 | 1177 | | var task = globalCatalog |
+| | 1 | 1178 | | ? Task.Run(() => CreateGlobalCatalogConnection(domainName, _ldapConfig.AuthType)) |
+| | 9 | 1179 | | : Task.Run(() => CreateLDAPConnection(domainName, skipCache, _ldapConfig.AuthType)); |
+| | | 1180 | | |
+| | 5 | 1181 | | var queryParams = new LDAPQueryParams(); |
+| | | 1182 | | |
+| | | 1183 | | LdapConnection conn; |
+| | | 1184 | | try |
+| | 5 | 1185 | | { |
+| | 5 | 1186 | | conn = task.ConfigureAwait(false).GetAwaiter().GetResult(); |
+| | 0 | 1187 | | } |
+| | 0 | 1188 | | catch (LdapException ldapException) |
+| | 0 | 1189 | | { |
+| | 0 | 1190 | | var errorString = |
+| | 0 | 1191 | | $"LDAP Exception {ldapException.ErrorCode} when creating connection for {ldapFilter} and domain {dom |
+| | 0 | 1192 | | queryParams.Exception = new LDAPQueryException(errorString, ldapException); |
+| | 0 | 1193 | | return queryParams; |
+| | | 1194 | | } |
+| | 5 | 1195 | | catch (LDAPQueryException ldapQueryException) |
+| | 5 | 1196 | | { |
+| | 5 | 1197 | | queryParams.Exception = ldapQueryException; |
+| | 5 | 1198 | | return queryParams; |
+| | | 1199 | | } |
+| | 0 | 1200 | | catch (Exception e) |
+| | 0 | 1201 | | { |
+| | 0 | 1202 | | var errorString = |
+| | 0 | 1203 | | $"Exception getting LDAP connection for {ldapFilter} and domain {domainName ?? "Default Domain"}"; |
+| | 0 | 1204 | | queryParams.Exception = new LDAPQueryException(errorString, e); |
+| | 0 | 1205 | | return queryParams; |
+| | | 1206 | | } |
+| | | 1207 | | |
+| | | 1208 | | //If we get a null connection, something went wrong, but we don't have an error to go with it for whatever r |
+| | 0 | 1209 | | if (conn == null) |
+| | 0 | 1210 | | { |
+| | 0 | 1211 | | var errorString = |
+| | 0 | 1212 | | $"LDAP connection is null for filter {ldapFilter} and domain {domainName ?? "Default Domain"}"; |
+| | 0 | 1213 | | queryParams.Exception = new LDAPQueryException(errorString); |
+| | 0 | 1214 | | return queryParams; |
+| | | 1215 | | } |
+| | | 1216 | | |
+| | | 1217 | | SearchRequest request; |
+| | | 1218 | | |
+| | | 1219 | | try |
| | 0 | 1220 | | { |
-| | 0 | 1221 | | var errorString = |
-| | 0 | 1222 | | $"Exception getting LDAP connection for {ldapFilter} and domain {domainName ?? "Default Domain"}"; |
-| | 0 | 1223 | | queryParams.Exception = new LDAPQueryException(errorString, e); |
-| | 0 | 1224 | | return queryParams; |
-| | | 1225 | | } |
-| | | 1226 | | |
-| | | 1227 | | //If we get a null connection, something went wrong, but we don't have an error to go with it for whatever r |
-| | 0 | 1228 | | if (conn == null) |
-| | 0 | 1229 | | { |
-| | 0 | 1230 | | var errorString = |
-| | 0 | 1231 | | $"LDAP connection is null for filter {ldapFilter} and domain {domainName ?? "Default Domain"}"; |
-| | 0 | 1232 | | queryParams.Exception = new LDAPQueryException(errorString); |
-| | 0 | 1233 | | return queryParams; |
-| | | 1234 | | } |
-| | | 1235 | | |
-| | | 1236 | | SearchRequest request; |
-| | | 1237 | | |
-| | | 1238 | | try |
-| | 0 | 1239 | | { |
-| | 0 | 1240 | | request = CreateSearchRequest(ldapFilter, scope, props, domainName, adsPath, showDeleted); |
-| | 0 | 1241 | | } |
-| | 0 | 1242 | | catch (LDAPQueryException ldapQueryException) |
-| | 0 | 1243 | | { |
-| | 0 | 1244 | | queryParams.Exception = ldapQueryException; |
-| | 0 | 1245 | | return queryParams; |
-| | | 1246 | | } |
-| | | 1247 | | |
-| | 0 | 1248 | | if (request == null) |
-| | 0 | 1249 | | { |
-| | 0 | 1250 | | var errorString = |
-| | 0 | 1251 | | $"Search request is null for filter {ldapFilter} and domain {domainName ?? "Default Domain"}"; |
-| | 0 | 1252 | | queryParams.Exception = new LDAPQueryException(errorString); |
-| | 0 | 1253 | | return queryParams; |
-| | | 1254 | | } |
-| | | 1255 | | |
-| | 0 | 1256 | | var pageControl = new PageResultRequestControl(500); |
-| | 0 | 1257 | | request.Controls.Add(pageControl); |
-| | | 1258 | | |
-| | 0 | 1259 | | if (includeAcl) |
-| | 0 | 1260 | | request.Controls.Add(new SecurityDescriptorFlagControl |
-| | 0 | 1261 | | { |
-| | 0 | 1262 | | SecurityMasks = SecurityMasks.Dacl | SecurityMasks.Owner |
-| | 0 | 1263 | | }); |
-| | | 1264 | | |
-| | 0 | 1265 | | queryParams.Connection = conn; |
-| | 0 | 1266 | | queryParams.SearchRequest = request; |
-| | 0 | 1267 | | queryParams.PageControl = pageControl; |
-| | | 1268 | | |
-| | 0 | 1269 | | return queryParams; |
-| | 5 | 1270 | | } |
-| | | 1271 | | |
-| | | 1272 | | private Group GetBaseEnterpriseDC(string domain) |
-| | 0 | 1273 | | { |
-| | 0 | 1274 | | var forest = GetForest(domain)?.Name; |
-| | 0 | 1275 | | if (forest == null) _log.LogWarning("Error getting forest, ENTDC sid is likely incorrect"); |
-| | 0 | 1276 | | var g = new Group { ObjectIdentifier = $"{forest}-S-1-5-9".ToUpper() }; |
-| | 0 | 1277 | | g.Properties.Add("name", $"ENTERPRISE DOMAIN CONTROLLERS@{forest ?? "UNKNOWN"}".ToUpper()); |
-| | 0 | 1278 | | g.Properties.Add("domainsid", GetSidFromDomainName(forest)); |
-| | 0 | 1279 | | g.Properties.Add("domain", forest); |
-| | 0 | 1280 | | return g; |
-| | 0 | 1281 | | } |
-| | | 1282 | | |
-| | | 1283 | | /// <summary> |
-| | | 1284 | | /// Updates the config for querying LDAP |
-| | | 1285 | | /// </summary> |
-| | | 1286 | | /// <param name="config"></param> |
-| | | 1287 | | public void UpdateLDAPConfig(LDAPConfig config) |
-| | 0 | 1288 | | { |
-| | 0 | 1289 | | _ldapConfig = config; |
-| | 0 | 1290 | | } |
-| | | 1291 | | |
-| | | 1292 | | private string GetDomainNameFromSidLdap(string sid) |
-| | 0 | 1293 | | { |
-| | 0 | 1294 | | var hexSid = Helpers.ConvertSidToHexSid(sid); |
+| | 0 | 1221 | | request = CreateSearchRequest(ldapFilter, scope, props, domainName, adsPath, showDeleted); |
+| | 0 | 1222 | | } |
+| | 0 | 1223 | | catch (LDAPQueryException ldapQueryException) |
+| | 0 | 1224 | | { |
+| | 0 | 1225 | | queryParams.Exception = ldapQueryException; |
+| | 0 | 1226 | | return queryParams; |
+| | | 1227 | | } |
+| | | 1228 | | |
+| | 0 | 1229 | | if (request == null) |
+| | 0 | 1230 | | { |
+| | 0 | 1231 | | var errorString = |
+| | 0 | 1232 | | $"Search request is null for filter {ldapFilter} and domain {domainName ?? "Default Domain"}"; |
+| | 0 | 1233 | | queryParams.Exception = new LDAPQueryException(errorString); |
+| | 0 | 1234 | | return queryParams; |
+| | | 1235 | | } |
+| | | 1236 | | |
+| | 0 | 1237 | | var pageControl = new PageResultRequestControl(500); |
+| | 0 | 1238 | | request.Controls.Add(pageControl); |
+| | | 1239 | | |
+| | 0 | 1240 | | if (includeAcl) |
+| | 0 | 1241 | | request.Controls.Add(new SecurityDescriptorFlagControl |
+| | 0 | 1242 | | { |
+| | 0 | 1243 | | SecurityMasks = SecurityMasks.Dacl | SecurityMasks.Owner |
+| | 0 | 1244 | | }); |
+| | | 1245 | | |
+| | 0 | 1246 | | queryParams.Connection = conn; |
+| | 0 | 1247 | | queryParams.SearchRequest = request; |
+| | 0 | 1248 | | queryParams.PageControl = pageControl; |
+| | | 1249 | | |
+| | 0 | 1250 | | return queryParams; |
+| | 5 | 1251 | | } |
+| | | 1252 | | |
+| | | 1253 | | private Group GetBaseEnterpriseDC(string domain) |
+| | 0 | 1254 | | { |
+| | 0 | 1255 | | var forest = GetForest(domain)?.Name; |
+| | 0 | 1256 | | if (forest == null) _log.LogWarning("Error getting forest, ENTDC sid is likely incorrect"); |
+| | 0 | 1257 | | var g = new Group { ObjectIdentifier = $"{forest}-S-1-5-9".ToUpper() }; |
+| | 0 | 1258 | | g.Properties.Add("name", $"ENTERPRISE DOMAIN CONTROLLERS@{forest ?? "UNKNOWN"}".ToUpper()); |
+| | 0 | 1259 | | g.Properties.Add("domainsid", GetSidFromDomainName(forest)); |
+| | 0 | 1260 | | g.Properties.Add("domain", forest); |
+| | 0 | 1261 | | return g; |
+| | 0 | 1262 | | } |
+| | | 1263 | | |
+| | | 1264 | | /// <summary> |
+| | | 1265 | | /// Updates the config for querying LDAP |
+| | | 1266 | | /// </summary> |
+| | | 1267 | | /// <param name="config"></param> |
+| | | 1268 | | public void UpdateLDAPConfig(LDAPConfig config) |
+| | 0 | 1269 | | { |
+| | 0 | 1270 | | _ldapConfig = config; |
+| | 0 | 1271 | | } |
+| | | 1272 | | |
+| | | 1273 | | private string GetDomainNameFromSidLdap(string sid) |
+| | 0 | 1274 | | { |
+| | 0 | 1275 | | var hexSid = Helpers.ConvertSidToHexSid(sid); |
+| | | 1276 | | |
+| | 0 | 1277 | | if (hexSid == null) |
+| | 0 | 1278 | | return null; |
+| | | 1279 | | |
+| | | 1280 | | //Search using objectsid first |
+| | 0 | 1281 | | var result = |
+| | 0 | 1282 | | QueryLDAP($"(&(objectclass=domain)(objectsid={hexSid}))", SearchScope.Subtree, |
+| | 0 | 1283 | | new[] { "distinguishedname" }, globalCatalog: true).DefaultIfEmpty(null).FirstOrDefault(); |
+| | | 1284 | | |
+| | 0 | 1285 | | if (result != null) |
+| | 0 | 1286 | | { |
+| | 0 | 1287 | | var domainName = Helpers.DistinguishedNameToDomain(result.DistinguishedName); |
+| | 0 | 1288 | | return domainName; |
+| | | 1289 | | } |
+| | | 1290 | | |
+| | | 1291 | | //Try trusteddomain objects with the securityidentifier attribute |
+| | 0 | 1292 | | result = |
+| | 0 | 1293 | | QueryLDAP($"(&(objectclass=trusteddomain)(securityidentifier={sid}))", SearchScope.Subtree, |
+| | 0 | 1294 | | new[] { "cn" }, globalCatalog: true).DefaultIfEmpty(null).FirstOrDefault(); |
| | | 1295 | | |
-| | 0 | 1296 | | if (hexSid == null) |
-| | 0 | 1297 | | return null; |
-| | | 1298 | | |
-| | | 1299 | | //Search using objectsid first |
-| | 0 | 1300 | | var result = |
-| | 0 | 1301 | | QueryLDAP($"(&(objectclass=domain)(objectsid={hexSid}))", SearchScope.Subtree, |
-| | 0 | 1302 | | new[] { "distinguishedname" }, globalCatalog: true).DefaultIfEmpty(null).FirstOrDefault(); |
-| | | 1303 | | |
-| | 0 | 1304 | | if (result != null) |
-| | 0 | 1305 | | { |
-| | 0 | 1306 | | var domainName = Helpers.DistinguishedNameToDomain(result.DistinguishedName); |
-| | 0 | 1307 | | return domainName; |
-| | | 1308 | | } |
-| | | 1309 | | |
-| | | 1310 | | //Try trusteddomain objects with the securityidentifier attribute |
-| | 0 | 1311 | | result = |
-| | 0 | 1312 | | QueryLDAP($"(&(objectclass=trusteddomain)(securityidentifier={sid}))", SearchScope.Subtree, |
-| | 0 | 1313 | | new[] { "cn" }, globalCatalog: true).DefaultIfEmpty(null).FirstOrDefault(); |
-| | | 1314 | | |
-| | 0 | 1315 | | if (result != null) |
-| | 0 | 1316 | | { |
-| | 0 | 1317 | | var domainName = result.GetProperty(LDAPProperties.CanonicalName); |
-| | 0 | 1318 | | return domainName; |
-| | | 1319 | | } |
-| | | 1320 | | |
-| | | 1321 | | //We didn't find anything so just return null |
-| | 0 | 1322 | | return null; |
-| | 0 | 1323 | | } |
-| | | 1324 | | |
-| | | 1325 | | /// <summary> |
-| | | 1326 | | /// Uses a socket and a set of bytes to request the NETBIOS name from a remote computer |
-| | | 1327 | | /// </summary> |
-| | | 1328 | | /// <param name="server"></param> |
-| | | 1329 | | /// <param name="domain"></param> |
-| | | 1330 | | /// <param name="netbios"></param> |
-| | | 1331 | | /// <returns></returns> |
-| | | 1332 | | private static bool RequestNETBIOSNameFromComputer(string server, string domain, out string netbios) |
-| | 0 | 1333 | | { |
-| | 0 | 1334 | | var receiveBuffer = new byte[1024]; |
-| | 0 | 1335 | | var requestSocket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp); |
-| | | 1336 | | try |
-| | 0 | 1337 | | { |
-| | | 1338 | | //Set receive timeout to 1 second |
-| | 0 | 1339 | | requestSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReceiveTimeout, 1000); |
-| | | 1340 | | EndPoint remoteEndpoint; |
-| | | 1341 | | |
-| | | 1342 | | //We need to create an endpoint to bind too. If its an IP, just use that. |
-| | 0 | 1343 | | if (IPAddress.TryParse(server, out var parsedAddress)) |
-| | 0 | 1344 | | remoteEndpoint = new IPEndPoint(parsedAddress, 137); |
-| | | 1345 | | else |
-| | | 1346 | | //If its not an IP, we're going to try and resolve it from DNS |
-| | | 1347 | | try |
-| | 0 | 1348 | | { |
-| | | 1349 | | IPAddress address; |
-| | 0 | 1350 | | if (server.Contains(".")) |
-| | 0 | 1351 | | address = Dns |
-| | 0 | 1352 | | .GetHostAddresses(server).First(x => x.AddressFamily == AddressFamily.InterNetwork); |
-| | | 1353 | | else |
-| | 0 | 1354 | | address = Dns.GetHostAddresses($"{server}.{domain}")[0]; |
-| | | 1355 | | |
-| | 0 | 1356 | | if (address == null) |
-| | 0 | 1357 | | { |
-| | 0 | 1358 | | netbios = null; |
-| | 0 | 1359 | | return false; |
-| | | 1360 | | } |
-| | | 1361 | | |
-| | 0 | 1362 | | remoteEndpoint = new IPEndPoint(address, 137); |
-| | 0 | 1363 | | } |
-| | 0 | 1364 | | catch |
-| | 0 | 1365 | | { |
-| | | 1366 | | //Failed to resolve an IP, so return null |
-| | 0 | 1367 | | netbios = null; |
-| | 0 | 1368 | | return false; |
-| | | 1369 | | } |
-| | | 1370 | | |
-| | 0 | 1371 | | var originEndpoint = new IPEndPoint(IPAddress.Any, 0); |
-| | 0 | 1372 | | requestSocket.Bind(originEndpoint); |
-| | | 1373 | | |
-| | | 1374 | | try |
-| | 0 | 1375 | | { |
-| | 0 | 1376 | | requestSocket.SendTo(NameRequest, remoteEndpoint); |
-| | 0 | 1377 | | var receivedByteCount = requestSocket.ReceiveFrom(receiveBuffer, ref remoteEndpoint); |
-| | 0 | 1378 | | if (receivedByteCount >= 90) |
-| | 0 | 1379 | | { |
-| | 0 | 1380 | | netbios = new ASCIIEncoding().GetString(receiveBuffer, 57, 16).Trim('\0', ' '); |
-| | 0 | 1381 | | return true; |
-| | | 1382 | | } |
-| | | 1383 | | |
-| | 0 | 1384 | | netbios = null; |
-| | 0 | 1385 | | return false; |
-| | | 1386 | | } |
-| | 0 | 1387 | | catch (SocketException) |
-| | 0 | 1388 | | { |
-| | 0 | 1389 | | netbios = null; |
-| | 0 | 1390 | | return false; |
-| | | 1391 | | } |
-| | | 1392 | | } |
-| | | 1393 | | finally |
-| | 0 | 1394 | | { |
-| | | 1395 | | //Make sure we close the socket if its open |
-| | 0 | 1396 | | requestSocket.Close(); |
-| | 0 | 1397 | | } |
-| | 0 | 1398 | | } |
-| | | 1399 | | |
-| | | 1400 | | /// <summary> |
-| | | 1401 | | /// Calls the NetWkstaGetInfo API on a hostname |
-| | | 1402 | | /// </summary> |
-| | | 1403 | | /// <param name="hostname"></param> |
-| | | 1404 | | /// <returns></returns> |
-| | | 1405 | | private async Task<NetAPIStructs.WorkstationInfo100?> GetWorkstationInfo(string hostname) |
-| | 0 | 1406 | | { |
-| | 0 | 1407 | | if (!await _portScanner.CheckPort(hostname)) |
-| | 0 | 1408 | | return null; |
-| | | 1409 | | |
-| | 0 | 1410 | | var result = NetAPIMethods.NetWkstaGetInfo(hostname); |
-| | 0 | 1411 | | if (result.IsSuccess) return result.Value; |
-| | | 1412 | | |
-| | 0 | 1413 | | return null; |
-| | 0 | 1414 | | } |
+| | 0 | 1296 | | if (result != null) |
+| | 0 | 1297 | | { |
+| | 0 | 1298 | | var domainName = result.GetProperty(LDAPProperties.CanonicalName); |
+| | 0 | 1299 | | return domainName; |
+| | | 1300 | | } |
+| | | 1301 | | |
+| | | 1302 | | //We didn't find anything so just return null |
+| | 0 | 1303 | | return null; |
+| | 0 | 1304 | | } |
+| | | 1305 | | |
+| | | 1306 | | /// <summary> |
+| | | 1307 | | /// Uses a socket and a set of bytes to request the NETBIOS name from a remote computer |
+| | | 1308 | | /// </summary> |
+| | | 1309 | | /// <param name="server"></param> |
+| | | 1310 | | /// <param name="domain"></param> |
+| | | 1311 | | /// <param name="netbios"></param> |
+| | | 1312 | | /// <returns></returns> |
+| | | 1313 | | private static bool RequestNETBIOSNameFromComputer(string server, string domain, out string netbios) |
+| | 0 | 1314 | | { |
+| | 0 | 1315 | | var receiveBuffer = new byte[1024]; |
+| | 0 | 1316 | | var requestSocket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp); |
+| | | 1317 | | try |
+| | 0 | 1318 | | { |
+| | | 1319 | | //Set receive timeout to 1 second |
+| | 0 | 1320 | | requestSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReceiveTimeout, 1000); |
+| | | 1321 | | EndPoint remoteEndpoint; |
+| | | 1322 | | |
+| | | 1323 | | //We need to create an endpoint to bind too. If its an IP, just use that. |
+| | 0 | 1324 | | if (IPAddress.TryParse(server, out var parsedAddress)) |
+| | 0 | 1325 | | remoteEndpoint = new IPEndPoint(parsedAddress, 137); |
+| | | 1326 | | else |
+| | | 1327 | | //If its not an IP, we're going to try and resolve it from DNS |
+| | | 1328 | | try |
+| | 0 | 1329 | | { |
+| | | 1330 | | IPAddress address; |
+| | 0 | 1331 | | if (server.Contains(".")) |
+| | 0 | 1332 | | address = Dns |
+| | 0 | 1333 | | .GetHostAddresses(server).First(x => x.AddressFamily == AddressFamily.InterNetwork); |
+| | | 1334 | | else |
+| | 0 | 1335 | | address = Dns.GetHostAddresses($"{server}.{domain}")[0]; |
+| | | 1336 | | |
+| | 0 | 1337 | | if (address == null) |
+| | 0 | 1338 | | { |
+| | 0 | 1339 | | netbios = null; |
+| | 0 | 1340 | | return false; |
+| | | 1341 | | } |
+| | | 1342 | | |
+| | 0 | 1343 | | remoteEndpoint = new IPEndPoint(address, 137); |
+| | 0 | 1344 | | } |
+| | 0 | 1345 | | catch |
+| | 0 | 1346 | | { |
+| | | 1347 | | //Failed to resolve an IP, so return null |
+| | 0 | 1348 | | netbios = null; |
+| | 0 | 1349 | | return false; |
+| | | 1350 | | } |
+| | | 1351 | | |
+| | 0 | 1352 | | var originEndpoint = new IPEndPoint(IPAddress.Any, 0); |
+| | 0 | 1353 | | requestSocket.Bind(originEndpoint); |
+| | | 1354 | | |
+| | | 1355 | | try |
+| | 0 | 1356 | | { |
+| | 0 | 1357 | | requestSocket.SendTo(NameRequest, remoteEndpoint); |
+| | 0 | 1358 | | var receivedByteCount = requestSocket.ReceiveFrom(receiveBuffer, ref remoteEndpoint); |
+| | 0 | 1359 | | if (receivedByteCount >= 90) |
+| | 0 | 1360 | | { |
+| | 0 | 1361 | | netbios = new ASCIIEncoding().GetString(receiveBuffer, 57, 16).Trim('\0', ' '); |
+| | 0 | 1362 | | return true; |
+| | | 1363 | | } |
+| | | 1364 | | |
+| | 0 | 1365 | | netbios = null; |
+| | 0 | 1366 | | return false; |
+| | | 1367 | | } |
+| | 0 | 1368 | | catch (SocketException) |
+| | 0 | 1369 | | { |
+| | 0 | 1370 | | netbios = null; |
+| | 0 | 1371 | | return false; |
+| | | 1372 | | } |
+| | | 1373 | | } |
+| | | 1374 | | finally |
+| | 0 | 1375 | | { |
+| | | 1376 | | //Make sure we close the socket if its open |
+| | 0 | 1377 | | requestSocket.Close(); |
+| | 0 | 1378 | | } |
+| | 0 | 1379 | | } |
+| | | 1380 | | |
+| | | 1381 | | /// <summary> |
+| | | 1382 | | /// Calls the NetWkstaGetInfo API on a hostname |
+| | | 1383 | | /// </summary> |
+| | | 1384 | | /// <param name="hostname"></param> |
+| | | 1385 | | /// <returns></returns> |
+| | | 1386 | | private async Task<NetAPIStructs.WorkstationInfo100?> GetWorkstationInfo(string hostname) |
+| | 0 | 1387 | | { |
+| | 0 | 1388 | | if (!await _portScanner.CheckPort(hostname)) |
+| | 0 | 1389 | | return null; |
+| | | 1390 | | |
+| | 0 | 1391 | | var result = NetAPIMethods.NetWkstaGetInfo(hostname); |
+| | 0 | 1392 | | if (result.IsSuccess) return result.Value; |
+| | | 1393 | | |
+| | 0 | 1394 | | return null; |
+| | 0 | 1395 | | } |
+| | | 1396 | | |
+| | | 1397 | | /// <summary> |
+| | | 1398 | | /// Creates a SearchRequest object for use in querying LDAP. |
+| | | 1399 | | /// </summary> |
+| | | 1400 | | /// <param name="filter">LDAP filter</param> |
+| | | 1401 | | /// <param name="scope">SearchScope to query</param> |
+| | | 1402 | | /// <param name="attributes">LDAP properties to fetch for each object</param> |
+| | | 1403 | | /// <param name="domainName">Domain to query</param> |
+| | | 1404 | | /// <param name="adsPath">ADS path to limit the query too</param> |
+| | | 1405 | | /// <param name="showDeleted">Include deleted objects in results</param> |
+| | | 1406 | | /// <returns>A built SearchRequest</returns> |
+| | | 1407 | | private SearchRequest CreateSearchRequest(string filter, SearchScope scope, string[] attributes, |
+| | | 1408 | | string domainName = null, string adsPath = null, bool showDeleted = false) |
+| | 0 | 1409 | | { |
+| | 0 | 1410 | | var domain = GetDomain(domainName)?.Name ?? domainName; |
+| | | 1411 | | |
+| | 0 | 1412 | | if (domain == null) |
+| | 0 | 1413 | | throw new LDAPQueryException( |
+| | 0 | 1414 | | $"Unable to create search request: GetDomain call failed for {domainName}"); |
| | | 1415 | | |
-| | | 1416 | | /// <summary> |
-| | | 1417 | | /// Creates a SearchRequest object for use in querying LDAP. |
-| | | 1418 | | /// </summary> |
-| | | 1419 | | /// <param name="filter">LDAP filter</param> |
-| | | 1420 | | /// <param name="scope">SearchScope to query</param> |
-| | | 1421 | | /// <param name="attributes">LDAP properties to fetch for each object</param> |
-| | | 1422 | | /// <param name="domainName">Domain to query</param> |
-| | | 1423 | | /// <param name="adsPath">ADS path to limit the query too</param> |
-| | | 1424 | | /// <param name="showDeleted">Include deleted objects in results</param> |
-| | | 1425 | | /// <returns>A built SearchRequest</returns> |
-| | | 1426 | | private SearchRequest CreateSearchRequest(string filter, SearchScope scope, string[] attributes, |
-| | | 1427 | | string domainName = null, string adsPath = null, bool showDeleted = false) |
-| | 0 | 1428 | | { |
-| | 0 | 1429 | | var domain = GetDomain(domainName)?.Name ?? domainName; |
-| | | 1430 | | |
-| | 0 | 1431 | | if (domain == null) |
-| | 0 | 1432 | | throw new LDAPQueryException($"Unable to create search request: GetDomain call failed for {domainName}") |
-| | | 1433 | | |
-| | 0 | 1434 | | var adPath = adsPath?.Replace("LDAP://", "") ?? $"DC={domain.Replace(".", ",DC=")}"; |
-| | | 1435 | | |
-| | 0 | 1436 | | var request = new SearchRequest(adPath, filter, scope, attributes); |
-| | 0 | 1437 | | request.Controls.Add(new SearchOptionsControl(SearchOption.DomainScope)); |
-| | 0 | 1438 | | if (showDeleted) |
-| | 0 | 1439 | | request.Controls.Add(new ShowDeletedControl()); |
-| | | 1440 | | |
-| | 0 | 1441 | | return request; |
-| | 0 | 1442 | | } |
-| | | 1443 | | |
-| | | 1444 | | /// <summary> |
-| | | 1445 | | /// Creates a LDAP connection to a global catalog server |
-| | | 1446 | | /// </summary> |
-| | | 1447 | | /// <param name="domainName">Domain to connect too</param> |
-| | | 1448 | | /// <param name="authType">Auth type to use. Defaults to Kerberos. Use Negotiate for netonly scenarios</param> |
-| | | 1449 | | /// <returns>A connected LdapConnection or null</returns> |
-| | | 1450 | | private async Task<LdapConnection> CreateGlobalCatalogConnection(string domainName = null, |
-| | | 1451 | | AuthType authType = AuthType.Kerberos) |
-| | 1 | 1452 | | { |
-| | | 1453 | | string targetServer; |
-| | 1 | 1454 | | if (_ldapConfig.Server != null) |
-| | 0 | 1455 | | { |
-| | 0 | 1456 | | targetServer = _ldapConfig.Server; |
-| | 0 | 1457 | | } |
-| | | 1458 | | else |
-| | 1 | 1459 | | { |
-| | 1 | 1460 | | var domain = GetDomain(domainName); |
-| | 1 | 1461 | | if (domain == null) |
-| | 1 | 1462 | | { |
-| | 1 | 1463 | | _log.LogDebug("Unable to create global catalog connection for domain {DomainName}: GetDomain failed" |
-| | 1 | 1464 | | throw new LDAPQueryException($"GetDomain call failed for {domainName}"); |
-| | | 1465 | | } |
-| | | 1466 | | |
-| | 0 | 1467 | | if (!_domainControllerCache.TryGetValue(domain.Name, out targetServer)) |
-| | 0 | 1468 | | targetServer = await GetUsableDomainController(domain); |
+| | 0 | 1416 | | var adPath = adsPath?.Replace("LDAP://", "") ?? $"DC={domain.Replace(".", ",DC=")}"; |
+| | | 1417 | | |
+| | 0 | 1418 | | var request = new SearchRequest(adPath, filter, scope, attributes); |
+| | 0 | 1419 | | request.Controls.Add(new SearchOptionsControl(SearchOption.DomainScope)); |
+| | 0 | 1420 | | if (showDeleted) |
+| | 0 | 1421 | | request.Controls.Add(new ShowDeletedControl()); |
+| | | 1422 | | |
+| | 0 | 1423 | | return request; |
+| | 0 | 1424 | | } |
+| | | 1425 | | |
+| | | 1426 | | /// <summary> |
+| | | 1427 | | /// Creates a LDAP connection to a global catalog server |
+| | | 1428 | | /// </summary> |
+| | | 1429 | | /// <param name="domainName">Domain to connect too</param> |
+| | | 1430 | | /// <param name="authType">Auth type to use. Defaults to Kerberos. Use Negotiate for netonly scenarios</param> |
+| | | 1431 | | /// <returns>A connected LdapConnection or null</returns> |
+| | | 1432 | | private async Task<LdapConnection> CreateGlobalCatalogConnection(string domainName = null, |
+| | | 1433 | | AuthType authType = AuthType.Kerberos) |
+| | 1 | 1434 | | { |
+| | | 1435 | | string targetServer; |
+| | 1 | 1436 | | if (_ldapConfig.Server != null) |
+| | 0 | 1437 | | { |
+| | 0 | 1438 | | targetServer = _ldapConfig.Server; |
+| | 0 | 1439 | | } |
+| | | 1440 | | else |
+| | 1 | 1441 | | { |
+| | 1 | 1442 | | var domain = GetDomain(domainName); |
+| | 1 | 1443 | | if (domain == null) |
+| | 1 | 1444 | | { |
+| | 1 | 1445 | | _log.LogDebug( |
+| | 1 | 1446 | | "Unable to create global catalog connection for domain {DomainName}: GetDomain failed", |
+| | 1 | 1447 | | domainName); |
+| | 1 | 1448 | | throw new LDAPQueryException($"GetDomain call failed for {domainName}"); |
+| | | 1449 | | } |
+| | | 1450 | | |
+| | 0 | 1451 | | if (!_domainControllerCache.TryGetValue(domain.Name, out targetServer)) |
+| | 0 | 1452 | | targetServer = await GetUsableDomainController(domain); |
+| | 0 | 1453 | | } |
+| | | 1454 | | |
+| | 0 | 1455 | | if (targetServer == null) |
+| | 0 | 1456 | | throw new LDAPQueryException($"No usable global catalog found for {domainName}"); |
+| | | 1457 | | |
+| | 0 | 1458 | | if (_globalCatalogConnections.TryGetValue(targetServer, out var connection)) |
+| | 0 | 1459 | | return connection; |
+| | | 1460 | | |
+| | 0 | 1461 | | connection = new LdapConnection(new LdapDirectoryIdentifier(targetServer, 3268)); |
+| | | 1462 | | |
+| | 0 | 1463 | | connection.SessionOptions.ProtocolVersion = 3; |
+| | | 1464 | | |
+| | 0 | 1465 | | if (_ldapConfig.Username != null) |
+| | 0 | 1466 | | { |
+| | 0 | 1467 | | var cred = new NetworkCredential(_ldapConfig.Username, _ldapConfig.Password); |
+| | 0 | 1468 | | connection.Credential = cred; |
| | 0 | 1469 | | } |
| | | 1470 | | |
-| | 0 | 1471 | | if (targetServer == null) |
-| | 0 | 1472 | | throw new LDAPQueryException($"No usable global catalog found for {domainName}"); |
-| | | 1473 | | |
-| | 0 | 1474 | | if (_globalCatalogConnections.TryGetValue(targetServer, out var connection)) |
-| | 0 | 1475 | | return connection; |
+| | 0 | 1471 | | if (_ldapConfig.DisableSigning) |
+| | 0 | 1472 | | { |
+| | 0 | 1473 | | connection.SessionOptions.Sealing = false; |
+| | 0 | 1474 | | connection.SessionOptions.Signing = false; |
+| | 0 | 1475 | | } |
| | | 1476 | | |
-| | 0 | 1477 | | connection = new LdapConnection(new LdapDirectoryIdentifier(targetServer, 3268)); |
+| | 0 | 1477 | | connection.AuthType = authType; |
| | | 1478 | | |
-| | 0 | 1479 | | connection.SessionOptions.ProtocolVersion = 3; |
-| | | 1480 | | |
-| | 0 | 1481 | | if (_ldapConfig.Username != null) |
-| | 0 | 1482 | | { |
-| | 0 | 1483 | | var cred = new NetworkCredential(_ldapConfig.Username, _ldapConfig.Password); |
-| | 0 | 1484 | | connection.Credential = cred; |
-| | 0 | 1485 | | } |
-| | | 1486 | | |
-| | 0 | 1487 | | if (_ldapConfig.DisableSigning) |
-| | 0 | 1488 | | { |
-| | 0 | 1489 | | connection.SessionOptions.Sealing = false; |
-| | 0 | 1490 | | connection.SessionOptions.Signing = false; |
-| | 0 | 1491 | | } |
-| | | 1492 | | |
-| | 0 | 1493 | | connection.AuthType = authType; |
-| | | 1494 | | |
-| | 0 | 1495 | | _globalCatalogConnections.TryAdd(targetServer, connection); |
-| | 0 | 1496 | | return connection; |
-| | 0 | 1497 | | } |
-| | | 1498 | | |
-| | | 1499 | | /// <summary> |
-| | | 1500 | | /// Creates an LDAP connection with appropriate options based off the ldap configuration. Caches connections |
-| | | 1501 | | /// </summary> |
-| | | 1502 | | /// <param name="domainName">The domain to connect too</param> |
-| | | 1503 | | /// <param name="skipCache">Skip the connection cache</param> |
-| | | 1504 | | /// <param name="authType">Auth type to use. Defaults to Kerberos. Use Negotiate for netonly scenarios</param> |
-| | | 1505 | | /// <returns>A connected LDAP connection or null</returns> |
-| | | 1506 | | private async Task<LdapConnection> CreateLDAPConnection(string domainName = null, bool skipCache = false, |
-| | | 1507 | | AuthType authType = AuthType.Kerberos) |
-| | 4 | 1508 | | { |
-| | | 1509 | | string targetServer; |
-| | 4 | 1510 | | if (_ldapConfig.Server != null) |
-| | 0 | 1511 | | targetServer = _ldapConfig.Server; |
-| | | 1512 | | else |
-| | 4 | 1513 | | { |
-| | 4 | 1514 | | var domain = GetDomain(domainName); |
-| | 4 | 1515 | | if (domain == null) |
-| | 4 | 1516 | | { |
-| | 4 | 1517 | | _log.LogDebug("Unable to create ldap connection for domain {DomainName}: GetDomain failed", domainNa |
-| | 4 | 1518 | | throw new LDAPQueryException($"Error creating LDAP connection: GetDomain call failed for {domainName |
-| | | 1519 | | } |
-| | | 1520 | | |
-| | 0 | 1521 | | if (!_domainControllerCache.TryGetValue(domain.Name, out targetServer)) |
-| | 0 | 1522 | | targetServer = await GetUsableDomainController(domain); |
-| | 0 | 1523 | | } |
-| | | 1524 | | |
-| | 0 | 1525 | | if (targetServer == null) |
-| | 0 | 1526 | | throw new LDAPQueryException($"No usable domain controller found for {domainName}"); |
-| | | 1527 | | |
-| | 0 | 1528 | | if (!skipCache) |
-| | 0 | 1529 | | if (_ldapConnections.TryGetValue(targetServer, out var conn)) |
-| | 0 | 1530 | | return conn; |
-| | | 1531 | | |
-| | 0 | 1532 | | var port = _ldapConfig.GetPort(); |
-| | 0 | 1533 | | var ident = new LdapDirectoryIdentifier(targetServer, port, false, false); |
-| | 0 | 1534 | | var connection = new LdapConnection(ident) { Timeout = new TimeSpan(0, 0, 5, 0) }; |
-| | 0 | 1535 | | if (_ldapConfig.Username != null) |
-| | 0 | 1536 | | { |
-| | 0 | 1537 | | var cred = new NetworkCredential(_ldapConfig.Username, _ldapConfig.Password); |
-| | 0 | 1538 | | connection.Credential = cred; |
-| | 0 | 1539 | | } |
-| | | 1540 | | |
-| | | 1541 | | //These options are important! |
-| | 0 | 1542 | | connection.SessionOptions.ProtocolVersion = 3; |
-| | 0 | 1543 | | connection.SessionOptions.ReferralChasing = ReferralChasingOptions.None; |
+| | 0 | 1479 | | _globalCatalogConnections.TryAdd(targetServer, connection); |
+| | 0 | 1480 | | return connection; |
+| | 0 | 1481 | | } |
+| | | 1482 | | |
+| | | 1483 | | /// <summary> |
+| | | 1484 | | /// Creates an LDAP connection with appropriate options based off the ldap configuration. Caches connections |
+| | | 1485 | | /// </summary> |
+| | | 1486 | | /// <param name="domainName">The domain to connect too</param> |
+| | | 1487 | | /// <param name="skipCache">Skip the connection cache</param> |
+| | | 1488 | | /// <param name="authType">Auth type to use. Defaults to Kerberos. Use Negotiate for netonly scenarios</param> |
+| | | 1489 | | /// <returns>A connected LDAP connection or null</returns> |
+| | | 1490 | | private async Task<LdapConnection> CreateLDAPConnection(string domainName = null, bool skipCache = false, |
+| | | 1491 | | AuthType authType = AuthType.Kerberos) |
+| | 4 | 1492 | | { |
+| | | 1493 | | string targetServer; |
+| | 4 | 1494 | | if (_ldapConfig.Server != null) |
+| | 0 | 1495 | | targetServer = _ldapConfig.Server; |
+| | | 1496 | | else |
+| | 4 | 1497 | | { |
+| | 4 | 1498 | | var domain = GetDomain(domainName); |
+| | 4 | 1499 | | if (domain == null) |
+| | 4 | 1500 | | { |
+| | 4 | 1501 | | _log.LogDebug("Unable to create ldap connection for domain {DomainName}: GetDomain failed", |
+| | 4 | 1502 | | domainName); |
+| | 4 | 1503 | | throw new LDAPQueryException( |
+| | 4 | 1504 | | $"Error creating LDAP connection: GetDomain call failed for {domainName}"); |
+| | | 1505 | | } |
+| | | 1506 | | |
+| | 0 | 1507 | | if (!_domainControllerCache.TryGetValue(domain.Name, out targetServer)) |
+| | 0 | 1508 | | targetServer = await GetUsableDomainController(domain); |
+| | 0 | 1509 | | } |
+| | | 1510 | | |
+| | 0 | 1511 | | if (targetServer == null) |
+| | 0 | 1512 | | throw new LDAPQueryException($"No usable domain controller found for {domainName}"); |
+| | | 1513 | | |
+| | 0 | 1514 | | if (!skipCache) |
+| | 0 | 1515 | | if (_ldapConnections.TryGetValue(targetServer, out var conn)) |
+| | 0 | 1516 | | return conn; |
+| | | 1517 | | |
+| | 0 | 1518 | | var port = _ldapConfig.GetPort(); |
+| | 0 | 1519 | | var ident = new LdapDirectoryIdentifier(targetServer, port, false, false); |
+| | 0 | 1520 | | var connection = new LdapConnection(ident) { Timeout = new TimeSpan(0, 0, 5, 0) }; |
+| | 0 | 1521 | | if (_ldapConfig.Username != null) |
+| | 0 | 1522 | | { |
+| | 0 | 1523 | | var cred = new NetworkCredential(_ldapConfig.Username, _ldapConfig.Password); |
+| | 0 | 1524 | | connection.Credential = cred; |
+| | 0 | 1525 | | } |
+| | | 1526 | | |
+| | | 1527 | | //These options are important! |
+| | 0 | 1528 | | connection.SessionOptions.ProtocolVersion = 3; |
+| | 0 | 1529 | | connection.SessionOptions.ReferralChasing = ReferralChasingOptions.None; |
+| | | 1530 | | |
+| | 0 | 1531 | | if (_ldapConfig.DisableSigning) |
+| | 0 | 1532 | | { |
+| | 0 | 1533 | | connection.SessionOptions.Sealing = false; |
+| | 0 | 1534 | | connection.SessionOptions.Signing = false; |
+| | 0 | 1535 | | } |
+| | | 1536 | | |
+| | 0 | 1537 | | if (_ldapConfig.SSL) |
+| | 0 | 1538 | | connection.SessionOptions.SecureSocketLayer = true; |
+| | | 1539 | | |
+| | 0 | 1540 | | if (_ldapConfig.DisableCertVerification) |
+| | 0 | 1541 | | connection.SessionOptions.VerifyServerCertificate = (ldapConnection, certificate) => true; |
+| | | 1542 | | |
+| | 0 | 1543 | | connection.AuthType = authType; |
| | | 1544 | | |
-| | 0 | 1545 | | if (_ldapConfig.DisableSigning) |
+| | 0 | 1545 | | _ldapConnections.AddOrUpdate(targetServer, connection, (s, ldapConnection) => |
| | 0 | 1546 | | { |
-| | 0 | 1547 | | connection.SessionOptions.Sealing = false; |
-| | 0 | 1548 | | connection.SessionOptions.Signing = false; |
-| | 0 | 1549 | | } |
+| | 0 | 1547 | | ldapConnection.Dispose(); |
+| | 0 | 1548 | | return connection; |
+| | 0 | 1549 | | }); |
| | | 1550 | | |
-| | 0 | 1551 | | if (_ldapConfig.SSL) |
-| | 0 | 1552 | | connection.SessionOptions.SecureSocketLayer = true; |
+| | 0 | 1551 | | return connection; |
+| | 0 | 1552 | | } |
| | | 1553 | | |
-| | 0 | 1554 | | if (_ldapConfig.DisableCertVerification) |
-| | 0 | 1555 | | connection.SessionOptions.VerifyServerCertificate = (ldapConnection, certificate) => true; |
-| | | 1556 | | |
-| | 0 | 1557 | | connection.AuthType = authType; |
+| | | 1554 | | private async Task<string> GetUsableDomainController(Domain domain, bool gc = false) |
+| | 0 | 1555 | | { |
+| | 0 | 1556 | | if (!gc && _domainControllerCache.TryGetValue(domain.Name.ToUpper(), out var dc)) |
+| | 0 | 1557 | | return dc; |
| | | 1558 | | |
-| | 0 | 1559 | | if (!skipCache) |
-| | 0 | 1560 | | _ldapConnections.TryAdd(targetServer, connection); |
-| | | 1561 | | |
-| | 0 | 1562 | | return connection; |
-| | 0 | 1563 | | } |
-| | | 1564 | | |
-| | | 1565 | | private async Task<string> GetUsableDomainController(Domain domain, bool gc = false) |
-| | 0 | 1566 | | { |
-| | 0 | 1567 | | if (!gc && _domainControllerCache.TryGetValue(domain.Name.ToUpper(), out var dc)) |
-| | 0 | 1568 | | return dc; |
-| | | 1569 | | |
-| | 0 | 1570 | | var port = gc ? 3268 : _ldapConfig.GetPort(); |
-| | 0 | 1571 | | var pdc = domain.PdcRoleOwner.Name; |
-| | 0 | 1572 | | if (await _portScanner.CheckPort(pdc, port)) |
-| | 0 | 1573 | | { |
-| | 0 | 1574 | | _domainControllerCache.TryAdd(domain.Name.ToUpper(), pdc); |
-| | 0 | 1575 | | _log.LogInformation("Found usable Domain Controller for {Domain} : {PDC}", domain.Name, pdc); |
-| | 0 | 1576 | | return pdc; |
-| | | 1577 | | } |
-| | | 1578 | | |
-| | | 1579 | | //If the PDC isn't reachable loop through the rest |
-| | 0 | 1580 | | foreach (DomainController domainController in domain.DomainControllers) |
-| | 0 | 1581 | | { |
-| | 0 | 1582 | | var name = domainController.Name; |
-| | 0 | 1583 | | if (!await _portScanner.CheckPort(name, port)) continue; |
-| | 0 | 1584 | | _log.LogInformation("Found usable Domain Controller for {Domain} : {PDC}", domain.Name, name); |
-| | 0 | 1585 | | _domainControllerCache.TryAdd(domain.Name.ToUpper(), name); |
-| | 0 | 1586 | | return name; |
-| | | 1587 | | } |
-| | | 1588 | | |
-| | | 1589 | | //If we get here, somehow we didn't get any usable DCs. Save it off as null |
-| | 0 | 1590 | | _domainControllerCache.TryAdd(domain.Name.ToUpper(), null); |
-| | 0 | 1591 | | _log.LogWarning("Unable to find usable domain controller for {Domain}", domain.Name); |
-| | 0 | 1592 | | return null; |
-| | 0 | 1593 | | } |
-| | | 1594 | | |
-| | | 1595 | | /// <summary> |
-| | | 1596 | | /// Normalizes a domain name to its full DNS name |
-| | | 1597 | | /// </summary> |
-| | | 1598 | | /// <param name="domain"></param> |
-| | | 1599 | | /// <returns></returns> |
-| | | 1600 | | internal string NormalizeDomainName(string domain) |
-| | 0 | 1601 | | { |
-| | 0 | 1602 | | if (domain == null) |
-| | 0 | 1603 | | return null; |
-| | | 1604 | | |
-| | 0 | 1605 | | var resolved = domain; |
-| | | 1606 | | |
-| | 0 | 1607 | | if (resolved.Contains(".")) |
-| | 0 | 1608 | | return domain.ToUpper(); |
-| | | 1609 | | |
-| | 0 | 1610 | | resolved = ResolveDomainNetbiosToDns(domain) ?? domain; |
-| | | 1611 | | |
-| | 0 | 1612 | | return resolved.ToUpper(); |
-| | 0 | 1613 | | } |
+| | 0 | 1559 | | var port = gc ? 3268 : _ldapConfig.GetPort(); |
+| | 0 | 1560 | | var pdc = domain.PdcRoleOwner.Name; |
+| | 0 | 1561 | | if (await _portScanner.CheckPort(pdc, port)) |
+| | 0 | 1562 | | { |
+| | 0 | 1563 | | _domainControllerCache.TryAdd(domain.Name.ToUpper(), pdc); |
+| | 0 | 1564 | | _log.LogInformation("Found usable Domain Controller for {Domain} : {PDC}", domain.Name, pdc); |
+| | 0 | 1565 | | return pdc; |
+| | | 1566 | | } |
+| | | 1567 | | |
+| | | 1568 | | //If the PDC isn't reachable loop through the rest |
+| | 0 | 1569 | | foreach (DomainController domainController in domain.DomainControllers) |
+| | 0 | 1570 | | { |
+| | 0 | 1571 | | var name = domainController.Name; |
+| | 0 | 1572 | | if (!await _portScanner.CheckPort(name, port)) continue; |
+| | 0 | 1573 | | _log.LogInformation("Found usable Domain Controller for {Domain} : {PDC}", domain.Name, name); |
+| | 0 | 1574 | | _domainControllerCache.TryAdd(domain.Name.ToUpper(), name); |
+| | 0 | 1575 | | return name; |
+| | | 1576 | | } |
+| | | 1577 | | |
+| | | 1578 | | //If we get here, somehow we didn't get any usable DCs. Save it off as null |
+| | 0 | 1579 | | _domainControllerCache.TryAdd(domain.Name.ToUpper(), null); |
+| | 0 | 1580 | | _log.LogWarning("Unable to find usable domain controller for {Domain}", domain.Name); |
+| | 0 | 1581 | | return null; |
+| | 0 | 1582 | | } |
+| | | 1583 | | |
+| | | 1584 | | /// <summary> |
+| | | 1585 | | /// Normalizes a domain name to its full DNS name |
+| | | 1586 | | /// </summary> |
+| | | 1587 | | /// <param name="domain"></param> |
+| | | 1588 | | /// <returns></returns> |
+| | | 1589 | | internal string NormalizeDomainName(string domain) |
+| | 0 | 1590 | | { |
+| | 0 | 1591 | | if (domain == null) |
+| | 0 | 1592 | | return null; |
+| | | 1593 | | |
+| | 0 | 1594 | | var resolved = domain; |
+| | | 1595 | | |
+| | 0 | 1596 | | if (resolved.Contains(".")) |
+| | 0 | 1597 | | return domain.ToUpper(); |
+| | | 1598 | | |
+| | 0 | 1599 | | resolved = ResolveDomainNetbiosToDns(domain) ?? domain; |
+| | | 1600 | | |
+| | 0 | 1601 | | return resolved.ToUpper(); |
+| | 0 | 1602 | | } |
+| | | 1603 | | |
+| | | 1604 | | /// <summary> |
+| | | 1605 | | /// Turns a domain Netbios name into its FQDN using the DsGetDcName function (TESTLAB -> TESTLAB.LOCAL) |
+| | | 1606 | | /// </summary> |
+| | | 1607 | | /// <param name="domainName"></param> |
+| | | 1608 | | /// <returns></returns> |
+| | | 1609 | | internal string ResolveDomainNetbiosToDns(string domainName) |
+| | 0 | 1610 | | { |
+| | 0 | 1611 | | var key = domainName.ToUpper(); |
+| | 0 | 1612 | | if (_netbiosCache.TryGetValue(key, out var flatName)) |
+| | 0 | 1613 | | return flatName; |
| | | 1614 | | |
-| | | 1615 | | /// <summary> |
-| | | 1616 | | /// Turns a domain Netbios name into its FQDN using the DsGetDcName function (TESTLAB -> TESTLAB.LOCAL) |
-| | | 1617 | | /// </summary> |
-| | | 1618 | | /// <param name="domainName"></param> |
-| | | 1619 | | /// <returns></returns> |
-| | | 1620 | | internal string ResolveDomainNetbiosToDns(string domainName) |
-| | 0 | 1621 | | { |
-| | 0 | 1622 | | var key = domainName.ToUpper(); |
-| | 0 | 1623 | | if (_netbiosCache.TryGetValue(key, out var flatName)) |
-| | 0 | 1624 | | return flatName; |
-| | | 1625 | | |
-| | 0 | 1626 | | var domain = GetDomain(domainName); |
-| | 0 | 1627 | | if (domain != null) |
-| | 0 | 1628 | | { |
-| | 0 | 1629 | | _netbiosCache.TryAdd(key, domain.Name); |
-| | 0 | 1630 | | return domain.Name; |
-| | | 1631 | | } |
-| | | 1632 | | |
-| | 0 | 1633 | | var computerName = _ldapConfig.Server; |
+| | 0 | 1615 | | var domain = GetDomain(domainName); |
+| | 0 | 1616 | | if (domain != null) |
+| | 0 | 1617 | | { |
+| | 0 | 1618 | | _netbiosCache.TryAdd(key, domain.Name); |
+| | 0 | 1619 | | return domain.Name; |
+| | | 1620 | | } |
+| | | 1621 | | |
+| | 0 | 1622 | | var computerName = _ldapConfig.Server; |
+| | | 1623 | | |
+| | 0 | 1624 | | var dci = _nativeMethods.CallDsGetDcName(computerName, domainName); |
+| | 0 | 1625 | | if (dci.IsSuccess) |
+| | 0 | 1626 | | { |
+| | 0 | 1627 | | flatName = dci.Value.DomainName; |
+| | 0 | 1628 | | _netbiosCache.TryAdd(key, flatName); |
+| | 0 | 1629 | | return flatName; |
+| | | 1630 | | } |
+| | | 1631 | | |
+| | 0 | 1632 | | return domainName.ToUpper(); |
+| | 0 | 1633 | | } |
| | | 1634 | | |
-| | 0 | 1635 | | var dci = _nativeMethods.CallDsGetDcName(computerName, domainName); |
-| | 0 | 1636 | | if (dci.IsSuccess) |
-| | 0 | 1637 | | { |
-| | 0 | 1638 | | flatName = dci.Value.DomainName; |
-| | 0 | 1639 | | _netbiosCache.TryAdd(key, flatName); |
-| | 0 | 1640 | | return flatName; |
-| | | 1641 | | } |
-| | | 1642 | | |
-| | 0 | 1643 | | return domainName.ToUpper(); |
-| | 0 | 1644 | | } |
-| | | 1645 | | |
-| | | 1646 | | /// <summary> |
-| | | 1647 | | /// Gets the range retrieval limit for a domain |
-| | | 1648 | | /// </summary> |
-| | | 1649 | | /// <param name="domainName"></param> |
-| | | 1650 | | /// <param name="defaultRangeSize"></param> |
-| | | 1651 | | /// <returns></returns> |
-| | | 1652 | | public int GetDomainRangeSize(string domainName = null, int defaultRangeSize = 750) |
-| | 4 | 1653 | | { |
-| | 4 | 1654 | | var domainPath = DomainNameToDistinguishedName(domainName); |
-| | | 1655 | | //Default to a page size of 750 for safety |
-| | 4 | 1656 | | if (domainPath == null) |
-| | 2 | 1657 | | { |
-| | 2 | 1658 | | _log.LogDebug("Unable to resolve domain {Domain} to distinguishedname to get page size", domainName ?? " |
-| | 2 | 1659 | | return defaultRangeSize; |
-| | | 1660 | | } |
-| | | 1661 | | |
-| | 2 | 1662 | | if (_ldapRangeSizeCache.TryGetValue(domainPath.ToUpper(), out var parsedPageSize)) |
-| | 0 | 1663 | | { |
-| | 0 | 1664 | | return parsedPageSize; |
-| | | 1665 | | } |
-| | | 1666 | | |
-| | 2 | 1667 | | var configPath = CommonPaths.CreateDNPath(CommonPaths.QueryPolicyPath, domainPath); |
-| | 2 | 1668 | | var enumerable = QueryLDAP("(objectclass=*)", SearchScope.Base, null, adsPath: configPath); |
-| | 2 | 1669 | | var config = enumerable.DefaultIfEmpty(null).FirstOrDefault(); |
-| | 3 | 1670 | | var pageSize = config?.GetArrayProperty(LDAPProperties.LdapAdminLimits).FirstOrDefault(x => x.StartsWith("Ma |
-| | 2 | 1671 | | if (pageSize == null) |
-| | 1 | 1672 | | { |
-| | 1 | 1673 | | _log.LogDebug("No LDAPAdminLimits object found for {Domain}", domainName); |
-| | 1 | 1674 | | _ldapRangeSizeCache.TryAdd(domainPath.ToUpper(), defaultRangeSize); |
-| | 1 | 1675 | | return defaultRangeSize; |
-| | | 1676 | | } |
-| | | 1677 | | |
-| | 1 | 1678 | | if (int.TryParse(pageSize.Split('=').Last(), out parsedPageSize)) |
-| | 1 | 1679 | | { |
-| | 1 | 1680 | | _ldapRangeSizeCache.TryAdd(domainPath.ToUpper(), parsedPageSize); |
-| | 1 | 1681 | | _log.LogInformation("Found page size {PageSize} for {Domain}", parsedPageSize, domainName ?? "current do |
-| | 1 | 1682 | | return parsedPageSize; |
-| | | 1683 | | } |
-| | | 1684 | | |
-| | 0 | 1685 | | _log.LogDebug("Failed to parse pagesize for {Domain}, returning default", domainName ?? "current domain"); |
-| | | 1686 | | |
-| | 0 | 1687 | | _ldapRangeSizeCache.TryAdd(domainPath.ToUpper(), defaultRangeSize); |
-| | 0 | 1688 | | return defaultRangeSize; |
-| | 4 | 1689 | | } |
-| | | 1690 | | |
-| | | 1691 | | private string DomainNameToDistinguishedName(string domain) |
-| | 4 | 1692 | | { |
-| | 4 | 1693 | | var resolvedDomain = GetDomain(domain)?.Name ?? domain; |
-| | 4 | 1694 | | return resolvedDomain == null ? null : $"DC={resolvedDomain.Replace(".", ",DC=")}"; |
-| | 4 | 1695 | | } |
-| | | 1696 | | |
-| | | 1697 | | private class ResolvedWellKnownPrincipal |
-| | | 1698 | | { |
-| | 3 | 1699 | | public string DomainName { get; set; } |
-| | 3 | 1700 | | public string WkpId { get; set; } |
-| | | 1701 | | } |
-| | | 1702 | | |
-| | | 1703 | | public string GetConfigurationPath(string domainName = null) |
-| | 0 | 1704 | | { |
-| | 0 | 1705 | | string path = domainName == null |
-| | 0 | 1706 | | ? "LDAP://RootDSE" |
-| | 0 | 1707 | | : $"LDAP://{NormalizeDomainName(domainName)}/RootDSE"; |
-| | | 1708 | | |
-| | | 1709 | | DirectoryEntry rootDse; |
-| | 0 | 1710 | | if (_ldapConfig.Username != null) |
-| | 0 | 1711 | | rootDse = new DirectoryEntry(path, _ldapConfig.Username, _ldapConfig.Password); |
-| | | 1712 | | else |
-| | 0 | 1713 | | rootDse = new DirectoryEntry(path); |
-| | | 1714 | | |
-| | 0 | 1715 | | return $"{rootDse.Properties["configurationNamingContext"]?[0]}"; |
-| | 0 | 1716 | | } |
-| | | 1717 | | |
-| | | 1718 | | public string GetSchemaPath(string domainName) |
-| | 0 | 1719 | | { |
-| | 0 | 1720 | | string path = domainName == null |
-| | 0 | 1721 | | ? "LDAP://RootDSE" |
-| | 0 | 1722 | | : $"LDAP://{NormalizeDomainName(domainName)}/RootDSE"; |
-| | | 1723 | | |
-| | | 1724 | | DirectoryEntry rootDse; |
-| | 0 | 1725 | | if (_ldapConfig.Username != null) |
-| | 0 | 1726 | | rootDse = new DirectoryEntry(path, _ldapConfig.Username, _ldapConfig.Password); |
-| | | 1727 | | else |
-| | 0 | 1728 | | rootDse = new DirectoryEntry(path); |
-| | | 1729 | | |
-| | 0 | 1730 | | return $"{rootDse.Properties["schemaNamingContext"]?[0]}"; |
-| | 0 | 1731 | | } |
-| | | 1732 | | |
-| | | 1733 | | public bool IsDomainController(string computerObjectId, string domainName) |
-| | 0 | 1734 | | { |
-| | 0 | 1735 | | var filter = new LDAPFilter().AddFilter(LDAPProperties.ObjectSID + "=" + computerObjectId, true).AddFilter(C |
-| | 0 | 1736 | | var res = QueryLDAP(filter.GetFilter(), SearchScope.Subtree, |
-| | 0 | 1737 | | CommonProperties.ObjectID, domainName: domainName); |
-| | 0 | 1738 | | if (res.Count() > 0) |
-| | 0 | 1739 | | return true; |
-| | 0 | 1740 | | return false; |
-| | 0 | 1741 | | } |
-| | | 1742 | | } |
-| | | 1743 | | } |
+| | | 1635 | | /// <summary> |
+| | | 1636 | | /// Gets the range retrieval limit for a domain |
+| | | 1637 | | /// </summary> |
+| | | 1638 | | /// <param name="domainName"></param> |
+| | | 1639 | | /// <param name="defaultRangeSize"></param> |
+| | | 1640 | | /// <returns></returns> |
+| | | 1641 | | public int GetDomainRangeSize(string domainName = null, int defaultRangeSize = 750) |
+| | 4 | 1642 | | { |
+| | 4 | 1643 | | var domainPath = DomainNameToDistinguishedName(domainName); |
+| | | 1644 | | //Default to a page size of 750 for safety |
+| | 4 | 1645 | | if (domainPath == null) |
+| | 2 | 1646 | | { |
+| | 2 | 1647 | | _log.LogDebug("Unable to resolve domain {Domain} to distinguishedname to get page size", |
+| | 2 | 1648 | | domainName ?? "current domain"); |
+| | 2 | 1649 | | return defaultRangeSize; |
+| | | 1650 | | } |
+| | | 1651 | | |
+| | 2 | 1652 | | if (_ldapRangeSizeCache.TryGetValue(domainPath.ToUpper(), out var parsedPageSize)) |
+| | 0 | 1653 | | { |
+| | 0 | 1654 | | return parsedPageSize; |
+| | | 1655 | | } |
+| | | 1656 | | |
+| | 2 | 1657 | | var configPath = CommonPaths.CreateDNPath(CommonPaths.QueryPolicyPath, domainPath); |
+| | 2 | 1658 | | var enumerable = QueryLDAP("(objectclass=*)", SearchScope.Base, null, adsPath: configPath); |
+| | 2 | 1659 | | var config = enumerable.DefaultIfEmpty(null).FirstOrDefault(); |
+| | 2 | 1660 | | var pageSize = config?.GetArrayProperty(LDAPProperties.LdapAdminLimits) |
+| | 3 | 1661 | | .FirstOrDefault(x => x.StartsWith("MaxPageSize", StringComparison.OrdinalIgnoreCase)); |
+| | 2 | 1662 | | if (pageSize == null) |
+| | 1 | 1663 | | { |
+| | 1 | 1664 | | _log.LogDebug("No LDAPAdminLimits object found for {Domain}", domainName); |
+| | 1 | 1665 | | _ldapRangeSizeCache.TryAdd(domainPath.ToUpper(), defaultRangeSize); |
+| | 1 | 1666 | | return defaultRangeSize; |
+| | | 1667 | | } |
+| | | 1668 | | |
+| | 1 | 1669 | | if (int.TryParse(pageSize.Split('=').Last(), out parsedPageSize)) |
+| | 1 | 1670 | | { |
+| | 1 | 1671 | | _ldapRangeSizeCache.TryAdd(domainPath.ToUpper(), parsedPageSize); |
+| | 1 | 1672 | | _log.LogInformation("Found page size {PageSize} for {Domain}", parsedPageSize, |
+| | 1 | 1673 | | domainName ?? "current domain"); |
+| | 1 | 1674 | | return parsedPageSize; |
+| | | 1675 | | } |
+| | | 1676 | | |
+| | 0 | 1677 | | _log.LogDebug("Failed to parse pagesize for {Domain}, returning default", domainName ?? "current domain"); |
+| | | 1678 | | |
+| | 0 | 1679 | | _ldapRangeSizeCache.TryAdd(domainPath.ToUpper(), defaultRangeSize); |
+| | 0 | 1680 | | return defaultRangeSize; |
+| | 4 | 1681 | | } |
+| | | 1682 | | |
+| | | 1683 | | private string DomainNameToDistinguishedName(string domain) |
+| | 4 | 1684 | | { |
+| | 4 | 1685 | | var resolvedDomain = GetDomain(domain)?.Name ?? domain; |
+| | 4 | 1686 | | return resolvedDomain == null ? null : $"DC={resolvedDomain.Replace(".", ",DC=")}"; |
+| | 4 | 1687 | | } |
+| | | 1688 | | |
+| | | 1689 | | private class ResolvedWellKnownPrincipal |
+| | | 1690 | | { |
+| | 3 | 1691 | | public string DomainName { get; set; } |
+| | 3 | 1692 | | public string WkpId { get; set; } |
+| | | 1693 | | } |
+| | | 1694 | | |
+| | | 1695 | | public string GetConfigurationPath(string domainName = null) |
+| | 0 | 1696 | | { |
+| | 0 | 1697 | | string path = domainName == null |
+| | 0 | 1698 | | ? "LDAP://RootDSE" |
+| | 0 | 1699 | | : $"LDAP://{NormalizeDomainName(domainName)}/RootDSE"; |
+| | | 1700 | | |
+| | | 1701 | | DirectoryEntry rootDse; |
+| | 0 | 1702 | | if (_ldapConfig.Username != null) |
+| | 0 | 1703 | | rootDse = new DirectoryEntry(path, _ldapConfig.Username, _ldapConfig.Password); |
+| | | 1704 | | else |
+| | 0 | 1705 | | rootDse = new DirectoryEntry(path); |
+| | | 1706 | | |
+| | 0 | 1707 | | return $"{rootDse.Properties["configurationNamingContext"]?[0]}"; |
+| | 0 | 1708 | | } |
+| | | 1709 | | |
+| | | 1710 | | public string GetSchemaPath(string domainName) |
+| | 0 | 1711 | | { |
+| | 0 | 1712 | | string path = domainName == null |
+| | 0 | 1713 | | ? "LDAP://RootDSE" |
+| | 0 | 1714 | | : $"LDAP://{NormalizeDomainName(domainName)}/RootDSE"; |
+| | | 1715 | | |
+| | | 1716 | | DirectoryEntry rootDse; |
+| | 0 | 1717 | | if (_ldapConfig.Username != null) |
+| | 0 | 1718 | | rootDse = new DirectoryEntry(path, _ldapConfig.Username, _ldapConfig.Password); |
+| | | 1719 | | else |
+| | 0 | 1720 | | rootDse = new DirectoryEntry(path); |
+| | | 1721 | | |
+| | 0 | 1722 | | return $"{rootDse.Properties["schemaNamingContext"]?[0]}"; |
+| | 0 | 1723 | | } |
+| | | 1724 | | |
+| | | 1725 | | public bool IsDomainController(string computerObjectId, string domainName) |
+| | 0 | 1726 | | { |
+| | 0 | 1727 | | var filter = new LDAPFilter().AddFilter(LDAPProperties.ObjectSID + "=" + computerObjectId, true) |
+| | 0 | 1728 | | .AddFilter(CommonFilters.DomainControllers, true); |
+| | 0 | 1729 | | var res = QueryLDAP(filter.GetFilter(), SearchScope.Subtree, |
+| | 0 | 1730 | | CommonProperties.ObjectID, domainName: domainName); |
+| | 0 | 1731 | | if (res.Count() > 0) |
+| | 0 | 1732 | | return true; |
+| | 0 | 1733 | | return false; |
+| | 0 | 1734 | | } |
+| | | 1735 | | } |
+| | | 1736 | | } |
-