public void GetHostEntry_ByManyIps()
{
var client = new LookupClient();
var nsServers = client.Query("google.com", QueryType.NS).Answers.NsRecords().ToArray();
Assert.True(nsServers.Length > 0);
foreach (var server in nsServers)
{
var ipAddress = client.GetHostEntry(server.NSDName).AddressList.First();
var result = client.GetHostEntry(ipAddress);
Assert.True(result.AddressList.Length >= 1);
Assert.Contains(ipAddress, result.AddressList);
Assert.True(result.Aliases.Length == 0);
// expecting always the name without . at the end!
Assert.Equal(server.NSDName.Value.Substring(0, server.NSDName.Value.Length - 1), result.HostName);
}
}
public void GetHostEntry_ByName_EmptyString()
{
var client = new LookupClient();
Action act = () => client.GetHostEntry("");
var ex = Record.Exception(act);
Assert.NotNull(ex);
Assert.Contains("hostNameOrAddress", ex.Message);
}
public void GetHostEntry_ByName_HostDoesNotExist_WithThrow()
{
var client = new LookupClient(
new LookupClientOptions(NameServer.GooglePublicDns)
{
ThrowDnsErrors = true
});
var ex = Assert.ThrowsAny <DnsResponseException>(() => client.GetHostEntry("lolhost"));
Assert.Equal(DnsResponseCode.NotExistentDomain, ex.Code);
}
public async Task Test_ReverseDNS()
{
LookupClient lookupClient = new LookupClient();
var hostEntry = lookupClient.GetHostEntry(Constants.TEST_REVERSEDNS_HOSTNAME);
var result = await lookupClient.QueryReverseAsync(hostEntry.AddressList[0],
queryOptions: new DnsQueryAndServerOptions() {
RequestDnsSecRecords=true,
Timeout = TimeSpan.FromMinutes(1)
});
Assert.IsNotNull(result, $"No data found for : {Constants.TEST_IP_V4}");
Assert.IsFalse(result.HasError, $"Error found {result.ErrorMessage}");
}
public void GetHostEntry_ByName_ManyAliases()
{
var client = new LookupClient(new LookupClientOptions(NameServer.GooglePublicDns)
{
ThrowDnsErrors = true
});
var result = client.GetHostEntry("dnsclient.michaco.net");
Assert.True(result.AddressList.Length >= 1);
Assert.True(result.Aliases.Length > 1);
Assert.Equal("dnsclient.michaco.net", result.HostName);
}
public void GetHostEntry_ByIp_NoHost_WithThrow()
{
var client = new LookupClient()
{
ThrowDnsErrors = true
};
Action act = () => client.GetHostEntry("1.0.0.0");
var ex = Record.Exception(act) as DnsResponseException;
Assert.NotNull(ex);
Assert.Equal(DnsResponseCode.NotExistentDomain, ex.Code);
}
public static void PrintHostEntry(string hostOrIp)
{
var lookup = new LookupClient();
IPHostEntry hostEntry = lookup.GetHostEntry(hostOrIp);
Console.WriteLine(hostEntry.HostName);
foreach (var ip in hostEntry.AddressList)
{
Console.WriteLine(ip);
}
foreach (var alias in hostEntry.Aliases)
{
Console.WriteLine(alias);
}
}
public static void GetAllShares(List <string> computers, string userSid, List <string> groupIds, Utilities.Options.Arguments arguments)
{
Console.WriteLine("[+] Starting share enumeration against {0} hosts\n", computers.Count);
var threadList = new List <Action>();
if (string.IsNullOrEmpty(userSid))
{
foreach (string computer in computers)
{
//GetComputerShares(computer, userSid, arguments);
threadList.Add(() => GetComputerShares(computer, userSid, groupIds, arguments));
}
}
else
{
IPEndPoint endpoint = new IPEndPoint(IPAddress.Parse(arguments.dc), 53);
LookupClient lookup = new LookupClient(endpoint);
var computerIpList = new List <string>()
{
};
foreach (var computerName in computers)
{
IPHostEntry hostEntry = lookup.GetHostEntry(computerName);
computerIpList.Add(hostEntry.AddressList[0].ToString());
}
UserCredentials credentials = new UserCredentials(arguments.userame.Split('\\')[0], arguments.userame.Split('\\')[1], arguments.password);
Impersonation.RunAsUser(credentials, LogonType.NewCredentials, (x) =>
{
foreach (string computer in computerIpList)
{
//GetComputerShares(computer, userSid, arguments);
threadList.Add(() => GetComputerShares(computer, userSid, groupIds, arguments));
}
});
}
var options = new ParallelOptions {
MaxDegreeOfParallelism = arguments.threads
};
Parallel.Invoke(options, threadList.ToArray());
Console.WriteLine("[+] Finished Enumerating Shares");
}
private static LookupClient GetDnsClient(string zoneName)
{
LookupClient generalClient = new LookupClient();
generalClient.UseCache = false;
var ns = generalClient.Query(zoneName, QueryType.NS);
var ip = ns.Answers.NsRecords().Select(s => generalClient.GetHostEntry(s.NSDName.Value));
var nameServers = ip.SelectMany(i => i.AddressList)
.Where(s => s.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork)
.ToArray();
LookupClient dnsClient = new LookupClient(nameServers);
dnsClient.UseCache = false;
return(dnsClient);
}
private static LookupClient GetDnsClient(params string[] hostnames)
{
LookupClient generalClient = new LookupClient();
LookupClient dnsClient = null;
generalClient.UseCache = false;
foreach (var hostname in hostnames)
{
var ns = generalClient.Query(hostname, QueryType.NS);
var ip = ns.Answers.NsRecords().Select(s => generalClient.GetHostEntry(s.NSDName.Value));
dnsClient = new LookupClient(ip.SelectMany(i => i.AddressList).Where(s => s.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork).ToArray());
dnsClient.UseCache = false;
}
return(dnsClient);
}
/// <summary>
/// Convert configured servers to a list of IP addresses
/// </summary>
/// <returns></returns>
private List <IPAddress> ParseDefaultClients()
{
var ret = new List <IPAddress>();
var items = _settings.Validation.DnsServers;
if (items != null)
{
foreach (var item in items)
{
if (IPAddress.TryParse(item, out var ip))
{
_log.Verbose("Adding {ip} as DNS server", ip);
ret.Add(ip);
}
else if (!string.IsNullOrEmpty(item))
{
if (item.Equals("[System]", StringComparison.OrdinalIgnoreCase))
{
_log.Debug("Adding local system default as DNS server");
ret.Add(new IPAddress(0));
}
else
{
var tempClient = new LookupClient();
var queryResult = tempClient.GetHostEntry(item);
var address = queryResult.AddressList.FirstOrDefault();
if (address != null)
{
_log.Verbose("Adding {item} ({ip}) as DNS server", item, address);
ret.Add(address);
}
else
{
_log.Warning("IP for DNS server {item} could not be resolved", item);
}
}
}
}
}
if (ret.Count == 0)
{
_log.Debug("Adding local system default as DNS server");
ret.Add(new IPAddress(0));
}
return(ret);
}
private List <LookupClientWrapper> ParseDefaultClients(DomainParseService domainParser, ILogService logService)
{
var ret = new List <LookupClientWrapper>();
var items = Properties.Settings.Default.DnsServer.ParseCsv();
if (items != null)
{
foreach (var item in items)
{
if (IPAddress.TryParse(item, out IPAddress ip))
{
_log.Debug("Adding {ip} as DNS server", ip);
ret.Add(GetClient(ip));
}
else if (!string.IsNullOrEmpty(item))
{
if (item.Equals("[System]", StringComparison.OrdinalIgnoreCase))
{
ret.Add(new LookupClientWrapper(domainParser, logService, null, this));
}
else
{
var tempClient = new LookupClient();
var queryResult = tempClient.GetHostEntry(item);
var address = queryResult.AddressList.FirstOrDefault();
if (address != null)
{
_log.Debug("Adding {item} ({ip}) as DNS server", address);
ret.Add(GetClient(address));
}
else
{
_log.Warning("IP for DNS server {item} could not be resolved", address);
}
}
}
}
}
if (ret.Count == 0)
{
_log.Debug("Adding local system default as DNS server");
ret.Add(new LookupClientWrapper(domainParser, logService, null, this));
}
return(ret);
}
public void TestQuery()
{
_client.Query("domain", QueryType.A);
_client.Query("domain", QueryType.A, QueryClass.IN);
_client.QueryReverse(IPAddress.Loopback);
_client.QueryServer(new[] { NameServer.GooglePublicDns.Address }, "domain", QueryType.A);
_client.QueryServer(new[] { NameServer.GooglePublicDns.Address }, "domain", QueryType.A, QueryClass.IN);
_client.QueryServerReverse(new[] { NameServer.GooglePublicDns.Address }, IPAddress.Loopback);
_client.QueryServer(new[] { NameServer.GooglePublicDns }, "domain", QueryType.A);
_client.QueryServer(new[] { NameServer.GooglePublicDns }, "domain", QueryType.A, QueryClass.IN);
_client.QueryServerReverse(new[] { NameServer.GooglePublicDns }, IPAddress.Loopback);
_client.GetHostEntry(IPAddress.Loopback);
_client.GetHostName(IPAddress.Loopback);
_client.ResolveService("domain", "srv", tag: null);
}
