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 AddressRangeTest_EN1()
{
var r = new WhoisResponse(null, ResponseEN1);
r.AddressRange.Begin.ToString().Is("192.41.192.0");
r.AddressRange.End.ToString().Is("192.41.192.255");
}
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());
}
/// <summary>
/// Incoming packets are pushed here for handling.
/// </summary>
protected unsafe override void HandlePacket(IPacketBase packet)
{
base.HandlePacket(packet);
//Update state from the client
if (packet is PushState)
{
PushState state = (PushState)packet;
//Push their state if it's the correct world ID
if (state.WorldID == WorldID)
{
LastState = state.State;
}
}
//Move the user in to a new zone
else if (packet is RequestZoneTransfer)
{
RequestZoneTransfer request = (RequestZoneTransfer)packet;
m_world.ZoneManager.RequestZoneTransfer(this, request.ZoneID);
}
//Resolve names
else if (packet is WhoisRequest)
{
WhoisRequest request = (WhoisRequest)packet;
WhoisResponse response = PacketFactory.CreatePacket <WhoisResponse>();
response.WorldID = request.WorldID;
string name = m_world.GetNameForWorldID(request.WorldID);
TextHelpers.StringToBuffer(name, response.Name, name.Length);
DeferredSendPacket(response);
}
}
private IpInfo ParseResponse(WhoisResponse response, string ip)
{
_logger.LogInformation($"Trying parse response for ip {ip}");
var lines = response.Raw.Split('\n').Select(x => TrimAll(x));
var result = new IpInfo
{
Ip = ip,
Company = response.OrganizationName
};
try
{
result.Subnet = response.AddressRange.ToCidrString();
}
catch
{
result.Subnet = response.AddressRange.ToString();
}
var countryLine = lines.FirstOrDefault(x => x.ToLower().Contains("country:"));
if (countryLine != null)
{
var country = TrimAll(countryLine.Split(':')[1]);
result.Country = country;
}
return(result);
}
/// <summary>
/// Search for domains and report progress
/// </summary>
/// <param name="domains">collection of domains</param>
/// <param name="inputs">collection of input strings</param>
/// <param name="progress">progress object</param>
/// <returns>collection of whois sites informations</returns>
public async Task <List <SiteInfo> > SearchAsync(IEnumerable <Domain> domains, IEnumerable <string> inputs, IProgress <ReportProgress> progress)
{
_Token = new CancellationTokenSource();
_ResetEvent = new AsyncManualResetEvent(true);
List <SiteInfo> sites = new List <SiteInfo>();
var addresses = inputs.SelectMany(input => domains.Where(dom => dom.IsChecked).Select(dom => input + dom.Name)).ToList();
int total = addresses.Count;
try
{
using (var whois = new WhoisLookup())
{
for (int i = 0; i < addresses.Count; i++)
{
//cancellation
_Token.Token.ThrowIfCancellationRequested();
//pause
await _ResetEvent.WaitAsync();
SiteInfo site;
var adr = addresses[i];
try
{
WhoisResponse response = await whois.LookupAsync(adr);
site = new SiteInfo(adr, response);
sites.Add(site);
}
catch (Whois.WhoisException)
{
site = SiteInfo.Error(adr);
sites.Add(site);
}
catch (System.TimeoutException)
{
site = SiteInfo.Error(adr);
sites.Add(site);
}
catch (Exception)
{
throw;
}
int done = (int)((i + 1.0) / total * 100.0);
progress.Report(new ReportProgress(done, $"Done {i + 1} of {total}", site));
}
}
return(sites);
}
catch (Exception)
{
throw;
}
}
public void TestGetServerWhenCached()
{
var existing = new WhoisResponse {
DomainName = new HostName("com")
};
cache.Set(existing);
var server = cache.Get("com");
Assert.AreEqual(existing, server);
}
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;
}
}
}
/// <summary>
/// Wrpper class for WhoisResponse.
/// </summary>
public WhoisResponseWrapper(WhoisResponse response)
{
if (response != null)
{
OrganizationName = response.OrganizationName;
RespondedServers = response.RespondedServers;
Raw = response.Raw;
}
else
{
RespondedServers = new string[0];
}
AddressRange = response?.AddressRange;
}
public void JsonSerializationByJSONNETTest()
{
var response = new WhoisResponse(
new[] { "whois.iana.org", "whois.apnic.net", "whois.afrinic.net" },
"NetRange: 150.126.0.0 - 150.126.255.255\n" +
"OrgName: Santa Cruz Operation Incorporated");
var json = JsonConvert.SerializeObject(response);
json.Is("{" +
@"""RespondedServers"":[""whois.iana.org"",""whois.apnic.net"",""whois.afrinic.net""]," +
@"""Raw"":""NetRange: 150.126.0.0 - 150.126.255.255\nOrgName: Santa Cruz Operation Incorporated""," +
@"""OrganizationName"":""Santa Cruz Operation Incorporated""," +
@"""AddressRange"":{""Begin"":""150.126.0.0"",""End"":""150.126.255.255""}" +
"}");
}
public async Task TestRedirectedWhoisData()
{
TcpReaderFactory.Bind(() => new FakeTcpReader("Redirected WHOIS Data"));
var record = new WhoisResponse(File.ReadAllText(@"..\..\..\Samples\Redirects\MarkMonitor.txt"));
var state = new LookupState
{
Response = record,
Options = WhoisOptions.Defaults,
Domain = "example.com"
};
var result = await visitor.Visit(state);
Assert.AreEqual("Redirected WHOIS Data", result.Response.Content);
}
public void TestCacheUpdate()
{
var first = new WhoisResponse {
DomainName = new HostName("com")
};
cache.Set(first);
var second = new WhoisResponse {
DomainName = new HostName("com")
};
cache.Set(second);
var server = cache.Get("com");
Assert.AreEqual(second, server);
}
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);
}
static void Main(string[] args)
{
//Init locals
WhoisResponse response = null;
WhoisLookup whois = null;
//Setup
SetupDomainList();
foreach (var d in _domains)
{
if (DomainIsValid(d))
{
try
{
whois = new WhoisLookup();
response = whois.Lookup(d);
AnalyzeData(response?.ParsedResponse);
Console.WriteLine("\n\n*******************************************************");
Console.WriteLine($"************************Results for {d}: ");
Console.WriteLine(ScrubContent(response?.Content));
Console.WriteLine("\n*******************************************************\n");
} // end try
catch (Exception)
{
Console.WriteLine($"Lookup of domain: {d} failed!");
Thread.Sleep(1000);
} // end catch
}
} // end foreach
PrintReport();
//Wait for input to exit
Console.Write("Press enter to exit...");
Console.ReadKey();
} // end method Main
/// <summary>
/// Whois lookup
/// </summary>
/// <param name="sld">second level domain</param>
/// <returns></returns>
public Domains.Whois.Whois Lookup(string sld)
{
try
{
WhoisResponse whoisResult = null;
whoisResult = this._whoisService.Lookup(sld)
.GetAwaiter()
.GetResult();
if (whoisResult.ParsedResponse == null)
{
throw new Exception("Can not resolve host");
}
var options = new JsonSerializerOptions
{
Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping,
PropertyNameCaseInsensitive = true
};
var json = JsonSerializer.Serialize(whoisResult.ParsedResponse, options);
var w = JsonSerializer.Deserialize <Domains.Whois.Whois>(json, options);
w.Status = "success";
w.CheckedAt = DateTimeOffset.Now.ToUnixTimeSeconds();
return(w);
}
catch (Exception ex)
{
// TODO: logging
Console.WriteLine(ex.Message);
return(new Domains.Whois.Whois
{
DomainName = sld,
Status = "error",
CheckedAt = DateTimeOffset.Now.ToUnixTimeSeconds()
});
}
}
/// <summary>
/// Determines whether a WHOIS response is a redirect response to another WHOIS server.
/// </summary>
public bool IsARedirectRecord(WhoisResponse response, out WhoisRedirect redirect)
{
redirect = null;
var pattern = Embedded.Patterns.Redirects.VerisignGrs;
var tokenizer = new TokenMatcher();
tokenizer.AddPattern(pattern, "verisign-grs.com");
if (tokenizer.TryMatch <WhoisRedirect>(response.Content, out var match))
{
Log.Debug("Found redirect for {0} to {1}", response.Domain, match.Result.Url);
redirect = match.Result;
if (string.IsNullOrEmpty(redirect.Url) == false)
{
return(true);
}
}
return(false);
}
/// <summary>
/// The query to send to the server chain. Likely wont work reliably with flags.
/// </summary>
/// <param name="QueryString">The Host or IP to query for</param>
/// <returns>A collection of data from the server chain</returns>
public QueryResponse Query(string QueryString)
{
QueryResponse queryResponse = new QueryResponse();
string whoisServer = "whois.arin.net";
string response = string.Empty;
bool requery = false;
do
{
if (!discoveredServers.Contains(whoisServer))
{
discoveredServers.Add(whoisServer);
}
requery = false;
TelnetClient client;
try
{
if (whoisServer.Contains(":"))
{
client = new TelnetClient(whoisServer.To(":"), int.Parse(whoisServer.From(":")));
}
else
{
client = new TelnetClient(whoisServer, 43);
}
response = client.Send(QueryString);
}
catch (Exception ex)
{
this.Error?.Invoke(ex);
return(queryResponse);
}
queryResponse.ServerResponses.Add(new ServerResponse()
{
Response = response,
Server = whoisServer,
Request = QueryString
});
if (response.Contains(REFERRAL_SERVER))
{
requery = true;
whoisServer = response.Split('\n').First(s => s.Contains(REFERRAL_SERVER)).From(": ");
if (whoisServer.Contains("://"))
{
whoisServer = whoisServer.From("://");
}
}
} while (requery);
WhoisResponse whoisResponse = new WhoisResponse();
foreach (string s in response.Split('\n'))
{
string toParse = s;
if (toParse.StartsWith("#") || toParse.StartsWith("%") || string.IsNullOrWhiteSpace(toParse))
{
continue;
}
Match m = Regex.Match(s, @"(.+)\s(.+)\s(\(.+\))\s([0-9\.]*)\s+-\s+([0-9\.]*)");
if (m.Success)
{
WhoisResponse thisResponse = new WhoisResponse();
thisResponse.OrgName = m.Groups[1].Value;
thisResponse.NetName = m.Groups[2].Value;
thisResponse.IPFrom = m.Groups[4].Value;
thisResponse.IPTo = m.Groups[5].Value;
queryResponse.WhoisResponses.Add(thisResponse);
continue;
}
if (!toParse.Contains(":"))
{
continue;
}
if (toParse.StartsWith("network:"))
{
toParse = toParse.From(":");
}
string key = toParse.To(":").Trim().ToLower();
string Value = toParse.From(":").Trim();
//wayport
switch (key)
{
case "inetnum":
case "netrange":
case "ip-network-block":
case "cidr":
case "ip-network":
if (Value.Contains("-"))
{
whoisResponse.IPFrom = Value.To("-").Trim();
whoisResponse.IPTo = Value.From("-").Trim();
}
else if (Value.Contains("/"))
{
whoisResponse.CIDR = string.IsNullOrWhiteSpace(whoisResponse.Country) ? Value : $"{Value}, {whoisResponse.CIDR}";
}
else
{
throw new Exception("Invalid network");
}
break;
case "netname":
case "network-name":
whoisResponse.NetName = Value;
break;
case "country":
case "country-code":
whoisResponse.Country = string.IsNullOrWhiteSpace(whoisResponse.Country) ? Value : whoisResponse.Country;
break;
case "org-name":
case "orgname":
case "organization;i":
whoisResponse.OrgName = Value;
break;
}
}
//Make sure we have something to return
if (!string.IsNullOrWhiteSpace(whoisResponse.CIDR) || !string.IsNullOrWhiteSpace(whoisResponse.IPFrom))
{
queryResponse.WhoisResponses.Add(whoisResponse);
}
return(queryResponse);
}
public void Set(WhoisResponse server)
{
cache.AddOrUpdate(server.DomainName.ToUnicodeString(), server, (tld, existing) => server);
}
protected override bool TryGetRegistrant(IList <Match> matches, WhoisResponse response, out Contact contact)
{
contact = null;
var contactIdMatch = matches
.FirstOrDefault(m => m.Token.Name == "Address");
if (contactIdMatch == null)
{
return(false);
}
var paragraph = contactIdMatch.Location.Paragraph;
contact = new Contact();
var count = 0;
foreach (var match in matches)
{
if (match.Location.Paragraph != paragraph)
{
continue;
}
switch (match.Token.Name)
{
case "Address":
var matchValueString = match.Value.ToString();
if (string.IsNullOrEmpty(contact.Name))
{
contact.Name = matchValueString;
}
else
{
contact.Address.Add(matchValueString);
}
count++;
break;
case "Phone":
contact.TelephoneNumber = match.Value.ToString();
break;
case "Fax":
contact.FaxNumber = match.Value.ToString();
break;
case "Email":
contact.Email = match.Value.ToString();
break;
case "Changed":
var dateTime = (DateTime)match.Value;
if (dateTime > response.Updated || !response.Updated.HasValue)
{
response.Updated = dateTime;
}
if (dateTime < response.Registered || !response.Registered.HasValue)
{
response.Registered = dateTime;
}
break;
}
}
return(count > 0);
}
public static string GetWhois(this string IpOrHostname)
{
WhoisResponse res = WhoisClient.Query(IpOrHostname);
return(res.OrganizationName + Environment.NewLine + res.AddressRange.ToString());
}
public void RespondedServersTest()
{
WhoisResponse WR = WhoisClient.Query("150.126.0.0");
Assert.AreEqual(3, WR.RespondedServers.Length);
}
