public void WhoisClientTest(string ip, string expectedOrgName, string expectedAddressRange)
{
var response = WhoisClient.Query(ip);
response.OrganizationName.Is(expectedOrgName);
response.AddressRange.ToString().Is(expectedAddressRange);
}
public void WhoisClientIP5Test()
{
WhoisResponse response = WhoisClient.Query("31.116.94.96");
Assert.AreEqual("EE Limited", response.OrganizationName);
Assert.AreEqual("31.64.0.0-31.127.255.255", response.AddressRange.ToString());
}
public void WhoisClientDomainTest()
{
WhoisResponse response = WhoisClient.Query("facebook.com");
Assert.AreEqual("Facebook, Inc.", response.OrganizationName);
Assert.IsNull(response.AddressRange);
}
public void WhoisClientIP3Test()
{
WhoisResponse response = WhoisClient.Query("108.234.177.20");
Assert.AreEqual("AT&T Internet Services", response.OrganizationName);
Assert.AreEqual("108.192.0.0-108.255.255.255", response.AddressRange.ToString());
}
public void WhoisClientIP4Test()
{
WhoisResponse response = WhoisClient.Query("190.190.132.64");
Assert.AreEqual("Prima S.A.", response.OrganizationName);
Assert.AreEqual("190.0.0.0-190.1.255.255", response.AddressRange.ToString());
}
public void WhoisClientIPTest()
{
WhoisResponse response = WhoisClient.Query("4.4.4.4");
Assert.AreEqual("Level 3 Communications, Inc. LVLT-STATIC-4-4-16 (NET-4-4-0-0-1)", response.OrganizationName);
Assert.AreEqual("4.4.0.0-4.4.255.255", response.AddressRange.ToString());
}
public void WhoisClientIP2Test()
{
WhoisResponse response = WhoisClient.Query("65.100.170.169");
Assert.AreEqual("Qwest Communications Company, LLC QWEST-INET-115 (NET-65-100-0-0-1)", response.OrganizationName);
Assert.AreEqual("65.100.0.0-65.103.255.255", response.AddressRange.ToString());
}
public async Task <Domain> SearchDomain(string domainName)
{
var domain = new Domain();
try
{
var response = await WhoisClient.QueryAsync(domainName);
var lookup = new LookupClient();
var result = await lookup.QueryAsync(domainName, QueryType.A);
var resultNS = await lookup.QueryAsync(domainName, QueryType.NS);
domain = new Domain(domainName);
domain.SetARecords(result);
domain.SetNsRecords(resultNS);
domain.SetWhois(response.Raw);
var hostResponse = await WhoisClient.QueryAsync(domain.Ip);
domain.HostedAt = hostResponse.OrganizationName;
domain.UpdatedAt = DateTime.Now;
return(domain);
}
catch (Exception e)
{
throw e;
}
}
public async Task WhoisClientAsyncTest(string ip, string expectedOrgName, string expectedAddressRange)
{
var response = await WhoisClient.QueryAsync(ip).ConfigureAwait(false);
response.OrganizationName.Is(expectedOrgName);
response.AddressRange.ToString().Is(expectedAddressRange);
}
//// =====================================================================================
/// <summary>
/// Initialise une nouvelle instance de la classe <see cref="WhoisControl" />.
/// </summary>
public WhoisControl()
{
this.worker = new BackgroundWorker();
// Initialisation de l'interface graphique
this.InitializeComponent();
// Gestionnaires d'événements
this.worker.DoWork += (sender, e) => e.Result = WhoisClient.GetHostInfo(e.Argument.ToString());
this.worker.RunWorkerCompleted += this.OnWorkCompleted;
// Laison des données
var defaultIcon = StockIcons.Internet.SmallBitmapImage;
this.InputComboBox.Items.Add(CreateComboBoxItem(".com", defaultIcon));
this.InputComboBox.Items.Add(CreateComboBoxItem(".net", defaultIcon));
this.InputComboBox.Items.Add(CreateComboBoxItem(".org", defaultIcon));
this.InputComboBox.Items.Add(new Separator {
Tag = string.Empty
});
foreach (var item in WhoisClient.KnownServers.Keys)
{
var icon = CountryFlags.GetCountryFlag(item);
this.InputComboBox.Items.Add(CreateComboBoxItem('.' + item, icon != null ? icon.SmallBitmapImage : defaultIcon));
}
// On force le rafraîchissement du rendu de la liste déroulante
Action emptyDelegate = delegate {};
this.InputComboBox.Dispatcher.Invoke(emptyDelegate, DispatcherPriority.Render);
}
public void WhoisClientTest(string domain, string expectedOrgName)
{
var response = WhoisClient.Query(domain);
response.OrganizationName.Is(expectedOrgName);
response.AddressRange.IsNull();
}
public async Task WhoisClientAsyncTest(string domain, string expectedOrgName)
{
var response = await WhoisClient.QueryAsync(domain).ConfigureAwait(false);
response.OrganizationName.Is(expectedOrgName);
response.AddressRange.IsNull();
}
public async Task <WhoisResponse> QueryByDomain(string domain)
{
return(await WhoisClient.QueryAsync(domain));
//Console.WriteLine("{0}", result.OrganizationName); // "Google Inc."
//Console.WriteLine(string.Join(" > ", result.RespondedServers)); // "whois.iana.org > whois.verisign-grs.com > whois.markmonitor.com"
//Console.WriteLine("----------------");
//Console.WriteLine(result.Raw);
}
static void Main(string[] args)
{
Console.WriteLine("WhoisClient.NET - TestDrive - NETFX40");
var result = WhoisClient.Query("8.8.8.8");
Console.WriteLine("{0} - {1}", result.AddressRange.Begin, result.AddressRange.End);
Console.WriteLine("{0}", result.OrganizationName);
Console.WriteLine(string.Join(" > ", result.RespondedServers));
}
private static async Task AsyncVersion()
{
Console.WriteLine("\n---- Async version ----");
var result = await WhoisClient.QueryAsync("8.8.8.8");
Console.WriteLine("{0} - {1}", result.AddressRange.Begin, result.AddressRange.End);
Console.WriteLine("{0}", result.OrganizationName);
Console.WriteLine(string.Join(" > ", result.RespondedServers));
}
public string Whois(string host)
{
if (this.cache.ContainsKey(host) == false)
{
var raw = this.FilterMessage(WhoisClient.Query(host).Raw);
this.cache[host] = raw;
}
return(this.cache[host]);
}
public async Task <WhoisResponseWrapper> Query_V2(string query, [FromQuery] string server = null, [FromQuery] int port = 43, [FromQuery] string encoding = "us-ascii")
{
if (string.IsNullOrWhiteSpace(query))
{
throw new ArgumentException("required 'query' parameter.", "query");
}
var response = await WhoisClient.QueryAsync(query, server, port, ParseEncoding(encoding));
return(new WhoisResponseWrapper(response));
}
public static string Whois(string host)
{
var result = WhoisClient.Query(host);
string output;
output = result.AddressRange.Begin.ToString() + " " + result.AddressRange.End.ToString() + "\n"; // "199.71.0.0 - 199.71.0.255"
output = output + result.OrganizationName.ToString() + "\n"; // "American Registry for Internet Numbers"
output = output + (string.Join(" > ", result.RespondedServers)); // "whois.arin.net"
return(output);
}
private static void SyncVersion()
{
var x = System.Text.Encoding.ASCII;
Console.WriteLine("\n---- Sync version ----");
var result = WhoisClient.Query("8.8.8.8", encoding: x);
Console.WriteLine("{0} - {1}", result.AddressRange.Begin, result.AddressRange.End);
Console.WriteLine("{0}", result.OrganizationName);
Console.WriteLine(string.Join(" > ", result.RespondedServers));
}
private string GetWhoisCompanyName(string ip)
{
var result = WhoisClient.Query(ip);
if (result != null)
{
var organizationName = (result.OrganizationName);
return(organizationName);
}
return(null);
}
private string GetWhoisNominationNetwork(string ip)
{
var result = WhoisClient.Query(ip);
if (result != null)
{
var nominationNetwork = (result.AddressRange.Begin.AddressFamily);
return(nominationNetwork.ToString());
}
return(null);
}
public async Task <string> RawQuery([FromQuery] string query, [FromQuery] string server, [FromQuery] int port = 43, [FromQuery] string encoding = "us-ascii")
{
if (string.IsNullOrWhiteSpace(query))
{
throw new ArgumentException("required 'query' parameter.", "query");
}
if (string.IsNullOrWhiteSpace(server))
{
throw new ArgumentException("required 'server' parameter.", "server");
}
return(await WhoisClient.RawQueryAsync(query, server, port, ParseEncoding(encoding)));
}
static void FetchDate()
{
Whois.Parsers.WhoisParser whoisParser = new Whois.Parsers.WhoisParser();
foreach (var p in db.DomainDetails.Where(x => x.HasDate == null && x.IsPing == true))
{
Console.WriteLine($"Fetch Date => {p.Name}");
WhoisResponse d = WhoisClient.Query(p.Name);
var d2 = whoisParser.Parse(d.RespondedServers[d.RespondedServers.Length - 1], d.Raw);
if (d2.Registered != null && d2.Updated != null && d2.Expiration != null)
{
p.HasDate = true;
p.RegisterAt = d2.Registered;
p.UpdateAt = d2.Updated;
p.ExpiryAt = d2.Expiration;
RecCount++;
}
else
{
long n = EMailExtract.NetConnectionCheckAndWait();
if (n == 1)
{
p.HasDate = false;
RecCount++;
}
else
{
d = WhoisClient.Query(p.Name);
d2 = whoisParser.Parse(d.RespondedServers[d.RespondedServers.Length - 1], d.Raw);
if (d2.Registered != null && d2.Updated != null && d2.Expiration != null)
{
p.HasDate = true;
p.RegisterAt = d2.Registered;
p.UpdateAt = d2.Updated;
p.ExpiryAt = d2.Expiration;
RecCount++;
}
else
{
p.HasDate = false;
RecCount++;
}
}
}
if (EMailExtract.escPressed)
{
return;
}
}
}
static void Main(string[] args)
{
// https://www.lacnic.net/2472/2/lacnic/request-bulk-whois-access
// https://afrinic.net/support/general-queries/how-can-i-request-for-bulk-whois-data
// https://www.ripe.net/manage-ips-and-asns/db/nrtm-mirroring
// https://www.arin.net/reference/research/bulkwhois/
// https://www.apnic.net/manage-ip/using-whois/bulk-access/
var domain = "targa.co.it";
var response = WhoisClient.Query(domain, encoding: Encoding.UTF8);
Console.WriteLine(response);
}
public void ShouldVerifyWhoisClientWorksOnShaw()
{
var whoisClient = new WhoisClient("68.146.10.100");
Assert.IsNotNull(whoisClient);
foreach (var item in whoisClient.Errors)
{
Console.WriteLine(item.Value);
}
Assert.IsTrue(whoisClient.Errors.Count == 0);
WhoisRecord response = whoisClient.GetWhoisRecord();
Assert.AreEqual("CA", response.RegistryData.Registrant.Country);
Assert.AreEqual("AB", response.RegistryData.Registrant.StateProv);
Assert.AreEqual("Calgary", response.RegistryData.Registrant.City);
Assert.IsTrue(response.RegistryData.Registrant.Name.ToLower().Contains("shaw"));
}
public void ShouldVerifyWhoisClientWorksOnShaw()
{
var whoisClient = new WhoisClient("68.146.10.100");
Assert.IsNotNull(whoisClient);
foreach (var item in whoisClient.Errors)
{
Console.WriteLine(item.Value);
}
Assert.IsTrue(whoisClient.Errors.Count == 0);
WhoisRecord response = whoisClient.GetWhoisRecord();
Assert.AreEqual("CA", response.RegistryData.Registrant.Country);
Assert.AreEqual("AB", response.RegistryData.Registrant.StateProv);
Assert.AreEqual("Calgary", response.RegistryData.Registrant.City);
Assert.IsTrue(response.RegistryData.Registrant.Name.ToLower().Contains("shaw"));
}
public void ShouldVerifyWhoisClientWorksOnGoogle()
{
WhoisRecord response;
var whoisClient = new WhoisClient("74.125.127.99");
Assert.IsNotNull(whoisClient);
foreach (var item in whoisClient.Errors)
{
Console.WriteLine(item.Value);
}
Assert.IsTrue(whoisClient.Errors.Count == 0);
response = whoisClient.GetWhoisRecord();
Assert.AreEqual("US", response.RegistryData.Registrant.Country);
Assert.AreEqual("CA", response.RegistryData.Registrant.StateProv);
Assert.AreEqual("Mountain View", response.RegistryData.Registrant.City);
Assert.IsTrue(response.RegistryData.Registrant.Name.ToLower().Contains("google"));
}
public void ShouldVerifyWhoisClientWorksOnGoogle()
{
WhoisRecord response;
var whoisClient = new WhoisClient("74.125.127.99");
Assert.IsNotNull(whoisClient);
foreach (var item in whoisClient.Errors)
{
Console.WriteLine(item.Value);
}
Assert.IsTrue(whoisClient.Errors.Count == 0);
response = whoisClient.GetWhoisRecord();
Assert.AreEqual("US", response.RegistryData.Registrant.Country);
Assert.AreEqual("CA", response.RegistryData.Registrant.StateProv);
Assert.AreEqual("Mountain View", response.RegistryData.Registrant.City);
Assert.IsTrue(response.RegistryData.Registrant.Name.ToLower().Contains("google"));
}
public async Task <IActionResult> WhoisLookup(string domain)
{
ViewData["domain"] = domain;
if (string.IsNullOrEmpty(domain))
{
return(View());
}
try
{
var result = await WhoisClient.QueryAsync(domain);
return(View(result));
} catch (Exception e)
{
ViewData["error"] = e.Message;
return(View());
}
}
public IpInfo GetInfo(string ip)
{
//if (IsPrivate(ip))
// return null;
WhoisResponse response = null;
try
{
var query = WhoisClient.Query(ip);
response = query;
return(ParseResponse(query, ip));
}
catch (Exception ex)
{
_logger.LogError(ex, $"Parsing failed for ip {ip}");
try
{
if (response != null && response.OrganizationName != null)
{
var org = response.OrganizationName;
var orgPassed = org;
if (org.Contains("(") && org.Contains(")"))
{
var openBracket = org.LastIndexOf('(');
var closeBracket = org.LastIndexOf(')');
orgPassed = org.Substring(openBracket + 1, closeBracket - openBracket - 1);
}
var q1 = WhoisClient.Query(orgPassed, response.RespondedServers.Last());
response = q1;
return(ParseResponse(q1, ip));
}
}
catch (Exception iex)
{
_logger.LogWarning(iex, $"Ошибка при получении информации об IP: {ip}");
}
}
return(null);
}
public async Task <Domain> SearchInWhoisAsync(string domainName)
{
Console.WriteLine("Entrei no search Whois");
Domain domain;
//busca valores na api do whois
var response = await WhoisClient.QueryAsync(domainName);
var lookup = new LookupClient();
var result = await lookup.QueryAsync(domainName, QueryType.ANY);
var record = result.Answers.ARecords().FirstOrDefault();
var address = record?.Address;
var ip = address?.ToString();
var hostResponse = await WhoisClient.QueryAsync(ip);
//verifica se houve erro na pesquisa. Se houver, cria um domínio com nome Error e a mensagem de erro
if (result.HasError)
{
domain = new Domain
{
Name = "Error",
WhoIs = result.ErrorMessage
};
}
//se não houve erro, atribui os valores certos ao domínio.
else
{
domain = new Domain
{
Name = domainName,
Ip = ip,
UpdatedAt = DateTime.Now,
WhoIs = response.Raw,
Ttl = record?.TimeToLive ?? 0,
HostedAt = hostResponse.OrganizationName
};
}
return(domain);
}
private async Task <Domain> GetDomain(string nameDomain)
{
var response = await WhoisClient.QueryAsync(nameDomain);
var result = await _lookupClient.QueryAsync(nameDomain, QueryType.ANY);
var record = result.Answers.ARecords().FirstOrDefault();
var address = record?.Address;
var ip = address?.ToString();
var hostResponse = await WhoisClient.QueryAsync(ip);
Domain domain = new Domain
{
Name = nameDomain,
Ip = ip,
UpdatedAt = DateTime.Now,
WhoIs = response.Raw,
Ttl = record?.TimeToLive ?? 0,
HostedAt = hostResponse.OrganizationName
};
return(domain);
}
