/// <summary></summary>
/// <param name="bytes"></param>
/// <param name="dnsMessage"></param>
/// <returns></returns>
public static bool TryParse(byte[] bytes, out DnsMessage dnsMessage)
{
if (!DnsMessage.TryParse(bytes, out dnsMessage))
{
return false;
}
return true;
}
public static async void ReturnContext(HttpContext context, bool returnMsg, DnsMessage dnsMsg)
{
var queryDictionary = context.Request.Query;
if (dnsMsg == null)
{
context.Response.StatusCode = StatusCodes.Status500InternalServerError;
await context.Response.WriteAsync("Remote DNS server timeout");
return;
}
if (returnMsg)
{
if (queryDictionary.ContainsKey("ct") && queryDictionary["ct"].ToString().Contains("json"))
{
context.Response.ContentType = "application/json";
await context.Response.WriteAsync(DohJsonEncoder.Encode(dnsMsg).ToString(Formatting.None));
}
else
{
context.Response.ContentType = "application/dns-message";
await context.Response.Body.WriteAsync(DnsEncoder.Encode(dnsMsg));
}
}
else
{
if (queryDictionary.ContainsKey("ct") && queryDictionary["ct"].ToString().Contains("message"))
{
context.Response.ContentType = "application/dns-message";
await context.Response.Body.WriteAsync(DnsEncoder.Encode(dnsMsg));
}
else
{
context.Response.ContentType = "application/json";
await context.Response.WriteAsync(DohJsonEncoder.Encode(dnsMsg).ToString(Formatting.None));
}
}
WriteLogCache(dnsMsg, context);
}
private async Task LogQuery(DnsMessage questionMessage, DnsMessage responseMessage, bool isBlacklisted)
{
await _logSemaphore.WaitAsync();
_totalCount++;
if (isBlacklisted)
{
_blockCount++;
}
if (SimpleLogging)
{
LogQuerySimple();
}
else
{
LogQueryFull(questionMessage, responseMessage, isBlacklisted);
}
_logSemaphore.Release();
}
private void SetupForwarding([NotNull] DnsMessage answer)
{
if (_portForwardingManager == null)
{
throw new InvalidOperationException();
}
var response = answer?.AnswerRecords.OfType <ARecord>().FirstOrDefault();
if (response == null || !response.Address.Equals(_redirectIP))
{
return;
}
Console.WriteLine("{0} : Found a record to proxy with https", response.Name);
_redirectIP = response.Address;
var ep = new IPEndPoint(_redirectIP, HttpsPort);
_portForwardingManager.StartForwarding(ep);
}
public static DnsMessage DnsQuery(IPAddress ipAddress, DnsMessage dnsMessage)
{
var client = new DnsClient(ipAddress, Config.TimeOut)
{
IsUdpEnabled = !Config.OnlyTcpEnable, IsTcpEnabled = true
};
for (var i = 0; i < Config.Tries; i++)
{
var aMessage = client.SendMessage(dnsMessage);
if (aMessage != null)
{
return(aMessage);
}
}
return(new DnsClient(ipAddress, Config.TimeOut)
{
IsTcpEnabled = true, IsUdpEnabled = false
}.SendMessage(dnsMessage));
}
public static async Task <DnsMessage> FromPostByteAsync(HttpContext context, bool ActiveEcs = true,
byte EcsDefaultMask = 24)
{
var msg = DnsMessage.Parse((await context.Request.BodyReader.ReadAsync()).Buffer.ToArray());
if (!Config.EcsEnable || !ActiveEcs || context.Request.Query.ContainsKey("no-ecs"))
{
return(msg);
}
if (IsEcsEnable(msg))
{
return(msg);
}
if (!msg.IsEDnsEnabled)
{
msg.IsEDnsEnabled = true;
}
msg.EDnsOptions.Options.Add(new ClientSubnetOption(EcsDefaultMask,
IPNetwork.Parse(RealIP.Get(context).ToString(), EcsDefaultMask).Network));
return(msg);
}
public DnsMessage Resolve(string name, RecordType recordType, RecordClass recordClass)
{
name = name.ToLower();
lock (lock_)
{
if (cache_.ContainsKey(name))
{
return(cache_[name]);
}
DnsMessage message = dns_.Resolve(name);
if (null == message)
{
return(null);
}
cache_.Add(name, message);
return(message);
}
}
static async Task handleQuery(object sender, QueryReceivedEventArgs e)
{
DnsMessage query = e.Query as DnsMessage;
DnsMessage response = query.CreateResponseInstance();
if (query == null || query.Questions.Count == 0)
{
e.Response = response;
return;
}
DnsQuestion[] records = new DnsQuestion[query.Questions.Count];
query.Questions.CopyTo(records);
foreach (DnsQuestion record in records)
{
String[] Labels = record.Name.Labels;
if (!Labels[Labels.Length - 1].ToLower().Equals("service"))
{
continue; // 서비스로 안끝나면 관심없음
}
String q = String.Concat(record.Name.Labels);
response.AnswerRecords.Add(new ARecord(record.Name, 10, ConfigMgr.localIp));
query.Questions.Remove(record);
}
if (query.Questions.Count != 0)
{
DnsClient client = new DnsClient(ConfigMgr.nameservers, 1000);
DnsMessage q = await client.SendMessageAsync(query);
if (q != null)
{
response.AnswerRecords.AddRange(q.AnswerRecords);
}
}
response.ReturnCode = ReturnCode.NoError;
response.IsRecursionDesired = false;
e.Response = response;
}
public static void Add(DnsMessage dnsMessage, HttpContext context)
{
foreach (var item in new List <DnsRecordBase>(dnsMessage.AnswerRecords).Where(item =>
(item.Name.IsSubDomainOf(DomainName.Parse("arashi-msg")) ||
item.Name.IsSubDomainOf(DomainName.Parse("nova-msg"))) && item.RecordType == RecordType.Txt))
{
dnsMessage.AnswerRecords.Remove(item);
}
if (dnsMessage.AnswerRecords.Count <= 0)
{
return;
}
var dnsRecordBase = dnsMessage.AnswerRecords.FirstOrDefault();
if (RealIP.TryGetFromDns(dnsMessage, out var ipAddress))
{
Add(new CacheItem(
$"DNS:{GeoIP.GetGeoStr(ipAddress)}{dnsRecordBase.Name}:{dnsRecordBase.RecordType}",
new CacheEntity
{
List = dnsMessage.AnswerRecords.ToList(),
Time = DateTime.Now,
ExpiresTime = DateTime.Now.AddSeconds(dnsRecordBase.TimeToLive)
}),
dnsRecordBase.TimeToLive);
}
else
{
Add(new CacheItem($"DNS:{dnsRecordBase.Name}:{dnsRecordBase.RecordType}",
new CacheEntity
{
List = dnsMessage.AnswerRecords.ToList(),
Time = DateTime.Now,
ExpiresTime = DateTime.Now.AddSeconds(dnsRecordBase.TimeToLive)
}),
dnsRecordBase.TimeToLive);
}
}
private static List <SpfRecord> GetValidSpfRecords(string spfDomain, RecordType recordType)
{
List <SpfRecord> res = new List <SpfRecord>();
DnsMessage dnsMessage = DnsClient.Default.Resolve(spfDomain, recordType);
if ((dnsMessage == null) || ((dnsMessage.ReturnCode != ReturnCode.NoError) && (dnsMessage.ReturnCode != ReturnCode.NxDomain)))
{
return(null);
}
foreach (TxtRecord txtRecord in dnsMessage.AnswerRecords.Where(record => record.RecordType == recordType).Cast <TxtRecord>())
{
SpfRecord spfRecord;
if (TryParse(txtRecord.TextData, out spfRecord))
{
res.Add(spfRecord);
}
}
return(res);
}
public static DnsMessage FromQueryContext(HttpContext context)
{
var queryDictionary = context.Request.Query;
var dnsQuestion = new DnsQuestion(DomainName.Parse(queryDictionary["name"]), RecordType.A,
RecordClass.INet);
if (queryDictionary.ContainsKey("type"))
{
if (Enum.TryParse(queryDictionary["type"], true, out RecordType rType))
{
dnsQuestion = new DnsQuestion(DomainName.Parse(queryDictionary["name"]), rType,
RecordClass.INet);
}
}
var dnsQMsg = new DnsMessage
{
IsEDnsEnabled = true,
IsQuery = true,
IsRecursionAllowed = true,
IsRecursionDesired = true,
TransactionID = Convert.ToUInt16(new Random(DateTime.Now.Millisecond).Next(1, 99))
};
dnsQMsg.Questions.Add(dnsQuestion);
if (queryDictionary.ContainsKey("edns_client_subnet"))
{
var ipStr = queryDictionary["edns_client_subnet"].ToString();
var ipNetwork = ipStr.Contains("/") ? IPNetwork.Parse(ipStr) : IPNetwork.Parse(ipStr, 24);
dnsQMsg.EDnsOptions.Options.Add(new ClientSubnetOption(ipNetwork.Cidr, ipNetwork.Network));
}
else
{
dnsQMsg.EDnsOptions.Options.Add(
new ClientSubnetOption(24, IPNetwork.Parse(RealIP.Get(context), 24).Network));
}
return(dnsQMsg);
}
public void NamePointerFormatting()
{
var message = new DnsMessage()
{
Queries = new[]
{
new DnsQuery("example.com", DnsRecordType.A, DnsEndpointClass.IN),
new DnsQuery("www.example.com", DnsRecordType.A, DnsEndpointClass.IN),
new DnsQuery("com", DnsRecordType.A, DnsEndpointClass.IN),
}
};
byte[] buffer = new byte[1024];
int bytesWritten = DnsParser.FormatMessage(message, buffer, enableNameCompression: true);
var message2 = DnsParser.ParseMessage(buffer.AsSpan(0, bytesWritten), out int bytesConsumed);
Assert.Equal(bytesWritten, bytesConsumed);
Assert.Equal(3, message2.Queries.Count);
Assert.Equal("example.com", message2.Queries[0].QueryName);
Assert.Equal("www.example.com", message2.Queries[1].QueryName);
Assert.Equal("com", message2.Queries[2].QueryName);
}
public static byte[] Encode(DnsMessage dnsQMsg)
{
dnsQMsg.IsRecursionAllowed = true;
dnsQMsg.IsRecursionDesired = true;
dnsQMsg.TransactionID = Convert.ToUInt16(new Random(DateTime.Now.Millisecond).Next(1, 10));
var args = new object[] { false, null };
if (info == null)
{
Parallel.ForEach(new DnsMessage().GetType().GetMethods(BindingFlags.Instance | BindingFlags.NonPublic), mInfo =>
{
if (mInfo.ToString() == "Int32 Encode(Boolean, Byte[] ByRef)")
{
info = mInfo;
}
});
}
info.Invoke(dnsQMsg, args);
//var dnsBytes = args[1] as byte[];
//if (dnsBytes[2] == 0) dnsBytes[2] = 1;
return(args[1] as byte[]);
}
public static byte[] Encode(DnsMessage dnsMsg, bool transIdEnable = false, ushort id = 0)
{
if (info == null)
{
Init();
}
dnsMsg.IsRecursionAllowed = true;
dnsMsg.IsRecursionDesired = true;
dnsMsg.IsQuery = false;
dnsMsg.IsEDnsEnabled = false;
dnsMsg.AdditionalRecords.Clear();
if (id != 0)
{
dnsMsg.TransactionID = id;
}
if (!transIdEnable)
{
dnsMsg.TransactionID = 0;
}
//if (dnsMsg.ReturnCode != ReturnCode.NoError) dnsMsg.TransactionID = 0;
foreach (var item in new List <DnsRecordBase>(dnsMsg.AnswerRecords).Where(item =>
item.Name.IsSubDomainOf(DomainName.Parse("arashi-msg")) ||
item.Name.IsSubDomainOf(DomainName.Parse("nova-msg"))))
{
dnsMsg.AnswerRecords.Remove(item);
}
//if (dnsBytes != null && dnsBytes[2] == 0) dnsBytes[2] = 1;
var args = new object[] { false, null };
if (info != null)
{
info.Invoke(dnsMsg, args);
}
return(bytesTrimEnd(args[1] as byte[]));
}
public static void WriteLogCache(DnsMessage dnsMessage, HttpContext context = null)
{
if (Config.CacheEnable)
{
Task.Run(() =>
{
if (context != null && Config.GeoCacheEnable)
{
DnsCache.Add(dnsMessage, context);
}
else
{
DnsCache.Add(dnsMessage);
}
});
}
if (Config.LogEnable)
{
Task.Run(() =>
{
var ip = RealIP.GetFromDns(dnsMessage, context);
if (LoggerFactory != null && Config.FullLogEnable)
{
var logger = LoggerFactory.CreateLogger("Arashi.Aoi");
dnsMessage.Questions.ForEach(o => logger.LogInformation(ip + ":Question:" + o));
dnsMessage.AnswerRecords.ForEach(o => logger.LogInformation(ip + ":Answer:" + o));
dnsMessage.AuthorityRecords.ForEach(o => logger.LogInformation(ip + ":Authority:" + o));
}
else
{
dnsMessage.Questions.ForEach(o => Console.WriteLine(ip + ":Question:" + o));
dnsMessage.AnswerRecords.ForEach(o => Console.WriteLine(ip + ":Answer:" + o));
dnsMessage.AuthorityRecords.ForEach(o => Console.WriteLine(ip + ":Authority:" + o));
}
});
}
}
private DnsMessageBase ProcessDnsQuery(DnsMessageBase message, IPAddress clientAddress, ProtocolType protocol)
{
state_.Logger.Debug("DNS query received");
message.IsQuery = false;
DnsMessage query = message as DnsMessage;
if (query == null)
{
message.ReturnCode = ReturnCode.ServerFailure;
return(message);
}
foreach (DnsQuestion question in query.Questions)
{
state_.Logger.Debug("DNS question of type {0} received", question.RecordType);
List <DnsRecordBase> records = ProcessQuestion(question);
if (records == null)
{
records = ForwardQuery(question);
}
if (records == null)
{
message.ReturnCode = ReturnCode.ServerFailure;
return(message);
}
else
{
query.AnswerRecords.AddRange(records);
}
}
return(message);
}
} // End Sub Test
static async Task OnQueryReceived(object sender, QueryReceivedEventArgs e)
{
DnsMessage message = e.Query as DnsMessage;
if (message == null)
return;
DnsMessage response = message.CreateResponseInstance();
if ((message.Questions.Count == 1))
{
// send query to upstream server
DnsQuestion question = message.Questions[0];
DnsMessage upstreamResponse = await DnsClient.Default.ResolveAsync(question.Name, question.RecordType, question.RecordClass);
// if got an answer, copy it to the message sent to the client
if (upstreamResponse != null)
{
foreach (DnsRecordBase record in (upstreamResponse.AnswerRecords))
{
response.AnswerRecords.Add(record);
} // Next record
foreach (DnsRecordBase record in (upstreamResponse.AdditionalRecords))
{
response.AdditionalRecords.Add(record);
} // Next record
response.ReturnCode = ReturnCode.NoError;
// set the response
e.Response = response;
} // End if (upstreamResponse != null)
} // End if ((message.Questions.Count == 1))
} // End Function OnQueryReceived
public static byte[] Encode(DnsMessage dnsQMsg)
{
var args = new object[] { false, null };
if (info == null)
{
foreach (var mInfo in dnsQMsg.GetType().GetMethods(BindingFlags.Instance | BindingFlags.NonPublic))
{
if (mInfo.ToString() == "Int32 Encode(Boolean, Byte[] ByRef)")
{
info = mInfo;
}
}
}
info.Invoke(dnsQMsg, args);
var dnsBytes = args[1] as byte[];
if (dnsBytes[2] == 0)
{
dnsBytes[2] = 1;
}
return(dnsBytes);
}
} // End Sub Test2
// Get reverse lookup adress for an ip address
public static void Test3()
{
ARSoft.Tools.Net.DomainName lookedUpDomainName = ARSoft.Tools.Net.IPAddressExtensions.GetReverseLookupDomain(
System.Net.IPAddress.Parse("192.0.2.1")
);
DnsMessage dnsMessage = DnsClient.Default.Resolve(lookedUpDomainName, RecordType.Ptr);
if ((dnsMessage == null) || ((dnsMessage.ReturnCode != ReturnCode.NoError) && (dnsMessage.ReturnCode != ReturnCode.NxDomain)))
{
throw new System.Exception("DNS request failed");
}
else
{
foreach (DnsRecordBase dnsRecord in dnsMessage.AnswerRecords)
{
PtrRecord ptrRecord = dnsRecord as PtrRecord;
if (ptrRecord != null)
{
System.Console.WriteLine(ptrRecord.PointerDomainName);
}
}
}
} // End Sub Test3
public static DnsMessage DnsQuery(DnsMessage dnsMessage, bool CnDns = true, bool Cache = true)
{
try
{
if (Config.CacheEnable && Cache && DnsCache.Contains(dnsMessage))
{
return(DnsCache.Get(dnsMessage));
}
if (Config.ChinaListEnable && CnDns &&
DNSChina.IsChinaName(dnsMessage.Questions.FirstOrDefault().Name) &&
dnsMessage.Questions.FirstOrDefault().RecordType == RecordType.A)
{
return(DNSChina.ResolveOverChinaDns(dnsMessage));
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
return(DnsQuery(UpEndPoint.Address, dnsMessage, UpEndPoint.Port, Config.TimeOut) ??
DnsQuery(BackUpEndPoint.Address, dnsMessage, BackUpEndPoint.Port, Config.TimeOut));
}
public static int Get_Server_Usage_Percent_If_Alive(IPAddress ip)
{
DnsClient dnsClient = new DnsClient(ip, 1500);
DnsMessage answer = dnsClient.Resolve(DomainName.Parse(Global.Config.ServerUsageFakeDomain));
if (answer != null)
{
foreach (var additionalRecord in answer.AdditionalRecords)
{
if (additionalRecord is ARecord aRecord &&
aRecord.Name.IsEqualOrSubDomainOf(DomainName.Parse(Global.Config.ServerUsageFakeDomain)))
{
return(Convert.ToInt32(aRecord.Name.Labels[0]));
}
}
}
return(505);
}
static async Task OnQueryReceived(object sender, QueryReceivedEventArgs e)
{
DnsMessage query = e.Query as DnsMessage;
if (query == null)
{
return;
}
DnsMessage response = query.CreateResponseInstance();
DnsQuestion question = response.Questions[0];
DnsMessage upstreamResponse = await DnsClient.Default.ResolveAsync(!question.Name.ToString().Contains("www.google.com")?question.Name : DomainName.Parse("www.yahoo.com"), question.RecordType, question.RecordClass);
foreach (DnsRecordBase record in upstreamResponse.AnswerRecords)
{
response.AnswerRecords.Add(record);
}
foreach (DnsRecordBase record in (upstreamResponse.AdditionalRecords))
{
response.AdditionalRecords.Add(record);
}
response.ReturnCode = ReturnCode.NoError;
e.Response = response;
}
private Task _server_QueryReceived(object sender, QueryReceivedEventArgs e)
{
DnsMessage query = e.Query as DnsMessage;
if (query == null)
{
return(Task.FromResult(0));
}
DnsMessage response = query.CreateResponseInstance();
if ((query.Questions.Count == 1))
{
// send query to upstream server
DnsQuestion question = query.Questions[0];
DnsMessage answer = DnsClient.Default.ResolveAsync(question.Name, question.RecordType, question.RecordClass).Result;
// if got an answer, copy it to the message sent to the client
if (answer != null)
{
foreach (DnsRecordBase record in (answer.AnswerRecords))
{
response.AnswerRecords.Add(record);
}
foreach (DnsRecordBase record in (answer.AdditionalRecords))
{
response.AdditionalRecords.Add(record);
}
response.ReturnCode = ReturnCode.NoError;
// set the response
e.Response = response;
}
}
return(Task.FromResult(0));
}
public static DnsMessage Get(DnsMessage dnsQMessage, HttpContext context = null)
{
var dCacheMsg = new DnsMessage
{
IsRecursionAllowed = true,
IsRecursionDesired = true,
TransactionID = dnsQMessage.TransactionID
};
if (context != null)
{
dCacheMsg.AnswerRecords.AddRange(Get(
$"{GeoIP.GetGeoStr(RealIP.GetFromDns(dnsQMessage, context))}{dnsQMessage.Questions.FirstOrDefault().Name}:{dnsQMessage.Questions.FirstOrDefault().RecordType}"));
}
else
{
dCacheMsg.AnswerRecords.AddRange(Get(
$"{dnsQMessage.Questions.FirstOrDefault().Name}:{dnsQMessage.Questions.FirstOrDefault().RecordType}"));
}
dCacheMsg.Questions.AddRange(dnsQMessage.Questions);
dCacheMsg.AnswerRecords.Add(new TxtRecord(DomainName.Parse("cache.doh.pp.ua"), 0,
"ArashiDNS.P Cached"));
return(dCacheMsg);
}
/**
* Get all domains pointed to by the given resource record name,
* looking in a single computer domain.
* @param rrName the DNS resource record name.
* @return a collection of domain names.
*/
private List <String> getDomains(DomainName rrName, DomainName domainName)
{
List <String> results = new List <String>();
DnsMessage dnsMessage = DNSClientUtil.GetDefaultClient().Resolve(rrName + domainName, RecordType.Ptr);
if ((dnsMessage == null) || dnsMessage.AnswerRecords.Count == 0 || ((dnsMessage.ReturnCode != ReturnCode.NoError) && (dnsMessage.ReturnCode != ReturnCode.NxDomain)))
{
throw new Exception("DNS request failed");
}
else
{
foreach (DnsRecordBase record in dnsMessage.AnswerRecords)
{
PtrRecord ptr = record as PtrRecord;
DomainName name = ptr.PointerDomainName;
results.Add(name.ToString());
}
}
return(results);
}
private bool TryLoadRecords(string domain, RecordType recordType, out SpfRecord record, out SpfQualifier errorResult)
{
DnsMessage dnsMessage = ResolveDns(domain, recordType);
if ((dnsMessage == null) || ((dnsMessage.ReturnCode != ReturnCode.NoError) && (dnsMessage.ReturnCode != ReturnCode.NxDomain)))
{
record = default(SpfRecord);
errorResult = SpfQualifier.TempError;
return(false);
}
var spfTextRecords =
dnsMessage.AnswerRecords
.Where(r => r.RecordType == recordType)
.Cast <ITextRecord>()
.Select(r => r.TextData)
.Where(SpfRecord.IsSpfRecord).ToList();
if (spfTextRecords.Count == 0)
{
record = default(SpfRecord);
errorResult = SpfQualifier.None;
return(false);
}
else if ((spfTextRecords.Count > 1) || !SpfRecord.TryParse(spfTextRecords[0], out record))
{
record = default(SpfRecord);
errorResult = SpfQualifier.PermError;
return(false);
}
else
{
errorResult = default(SpfQualifier);
return(true);
}
}
static void Main(string[] args)
{
DNSEncoder.Init();
var server = new WebSocketServer("ws://0.0.0.0:3030");
server.ListenerSocket.NoDelay = true;
server.Start(ws =>
{
ws.OnOpen = () => Console.WriteLine(ws.ConnectionInfo.ClientIpAddress + ":Open!");
ws.OnClose = () => Console.WriteLine(ws.ConnectionInfo.ClientIpAddress + ":Close!");
ws.OnBinary = msg =>
{
using (var bgWorker = new BackgroundWorker())
{
bgWorker.DoWork += (sender, eventArgs) =>
{
var dnsQMsg = DnsMessage.Parse(msg);
var dnsRMsg =
new DnsClient(IPAddress.Parse("8.8.8.8"), 1000).SendMessage(dnsQMsg);
ws.Send(DNSEncoder.Encode(dnsRMsg));
Console.ForegroundColor = ConsoleColor.Cyan;
dnsQMsg.Questions.ForEach(o => Console.WriteLine("Qu:" + o));
Console.ForegroundColor = ConsoleColor.Green;
dnsRMsg.AnswerRecords.ForEach(o => Console.WriteLine("An:" + o));
Console.ForegroundColor = ConsoleColor.DarkGreen;
dnsRMsg.AuthorityRecords.ForEach(o => Console.WriteLine("Au:" + o));
Console.ForegroundColor = ConsoleColor.Green;
};
bgWorker.RunWorkerAsync();
}
};
});
Console.ReadLine();
}
private static async Task Server_QueryReceived(object sender, QueryReceivedEventArgs eventArgs)
{
DnsMessage query = eventArgs.Query as DnsMessage;
if (query != null)
{
DnsMessage response = query.CreateResponseInstance();
if ((query.Questions.Count == 1))
{
DnsQuestion question = query.Questions[0];
System.Diagnostics.Trace.WriteLine(question.Name.ToString());
//DnsMessage upstreamResponse = await DnsClient.Default.ResolveAsync(question.Name, question.RecordType, question.RecordClass);
DnsClient dc = new DnsClient(IPAddress.Parse("192.168.1.254"), 5000);
DnsMessage upstreamResponse = await dc.ResolveAsync(question.Name, question.RecordType, question.RecordClass);
if (upstreamResponse != null)
{
foreach (DnsRecordBase record in (upstreamResponse.AnswerRecords))
{
response.AnswerRecords.Add(record);
}
foreach (DnsRecordBase record in (upstreamResponse.AdditionalRecords))
{
response.AdditionalRecords.Add(record);
}
response.ReturnCode = ReturnCode.NoError;
// set the response
eventArgs.Response = response;
}
}
}
//await Task.Delay(1000);
}
static void Benchmark(int repetitions)
{
Domain domain = new Domain("org");
var thing = domain.AddSubdomain(new Domain("iansweb"));
thing.AddSubdomain(new Domain("forum")).A_Records.Add(new DNS.Messages.Records.A(new byte[] { 127, 0, 0, 1 }));
thing.A_Records.Add(new DNS.Messages.Records.A(new byte[] { 127, 0, 0, 1 }));
var now = DateTime.Now;
for (int i = 0; i < repetitions; i++)
{
var parsed = Parser.Parse(ahh);
//var ans = record.GetAnswer(parsed.Questions[0]);
List <Answer> answers = new List <Answer>();
foreach (var question in parsed.Questions)
{
var ams = domain.RetrieveSubDomain(question.RawBytes);
Answer[] answerss = new Answer[0];
if (ams != null)
{
answerss = ams.GetAnswers(question);
}
if (ams == null)
{
Console.WriteLine($"{question.Raw} {question.Type} {question.Class} -> Name not found");
}
else
{
if (answerss.Length < 1)
{
Console.WriteLine($"{question.Raw} {question.Type} {question.Class} -> No records found");
}
else
{
Console.WriteLine($"{question.Raw} {question.Type} {question.Class} -> {ams.FQDN}");
foreach (var a in answerss)
{
Console.WriteLine($"\t{a.StringFQDN} -> {a.a}");
}
}
}
}
ReplyCodeBuilder replyCodeBuilder = new ReplyCodeBuilder();
replyCodeBuilder.answers = (ushort)answers.Count;
replyCodeBuilder.questions = parsed.QuestionCount;
replyCodeBuilder.isQuery = false;
replyCodeBuilder.recursionAvailable = false;
replyCodeBuilder.recursionDesired = false;
replyCodeBuilder.responseCode = Header.ResponseCodes.NOERROR;
replyCodeBuilder.truncation = false;
replyCodeBuilder.authorities = 0;
replyCodeBuilder.authoritativeAnswer = true;
replyCodeBuilder.additional = 0;
HeaderBuilder headerBuilder = new HeaderBuilder(replyCodeBuilder);
headerBuilder.id = parsed.Id;
DnsMessage dnsMessage = new DnsMessage(headerBuilder)
{
Answers = answers.ToArray(), Questions = parsed.Questions
};
var pa = Parser.Parse(Serializer.Serialize(dnsMessage));
}
var time = DateTime.Now.Subtract(now);
Console.WriteLine($"Approximate Execution Time:\r\n{((double)time.Ticks * 100000 / (double)repetitions)} Picoseconds\r\n{(double)(((double)time.Ticks / (double)repetitions) * 100)} Nanoseconds\r\n{((double)time.Milliseconds / repetitions)} Milliseconds\r\n({time.Ticks} Ticks * 100000 / {repetitions} Repetitions)");
}
static void DoThing()
{
DateTime start;
TimeSpan recieving;
TimeSpan parsing;
TimeSpan answering;
TimeSpan sending;
DateTime end;
start = DateTime.Now;
var parsed = Parser.Parse(Recieve(ref start, out recieving));
parsing = DateTime.Now.Subtract(start);
List <Answer> answers = new List <Answer>();
ReplyCodeBuilder replyCodeBuilder = new ReplyCodeBuilder
{
isQuery = false,
recursionAvailable = false,
recursionDesired = false,
truncation = false,
authorities = 0,
authoritativeAnswer = true,
additional = 0,
};
if (parsed.OpCode == Header.OpCodes.IQUERY)
{
replyCodeBuilder.responseCode = Header.ResponseCodes.SERVERFAILURE;
}
else
{
foreach (var question in parsed.Questions)
{
var ams = domainHandler.RetrieveSubDomain(question.RawBytes);
Answer[] answerss = new Answer[0];
if (ams != null)
{
answerss = ams.GetAnswers(question);
}
if (ams == null)
{
Console.WriteLine($"{question.Raw} {question.Type} {question.Class} -> Name not found");
replyCodeBuilder.responseCode = Header.ResponseCodes.NAMEERROR;
}
else
{
if (answerss.Length < 1)
{
Console.WriteLine($"{question.Raw} {question.Type} {question.Class} -> No records found");
}
else
{
Console.WriteLine($"{question.Raw} {question.Type} {question.Class} -> {ams.FQDN}");
replyCodeBuilder.responseCode = Header.ResponseCodes.NOERROR;
answers.AddRange(answerss);
foreach (var a in answerss)
{
Console.WriteLine($"\t{question.Raw} -> {a.a}");
}
}
}
}
}
answering = DateTime.Now.Subtract(start);
replyCodeBuilder.answers = (ushort)answers.Count;
replyCodeBuilder.questions = parsed.QuestionCount;
HeaderBuilder headerBuilder = new HeaderBuilder(replyCodeBuilder);
headerBuilder.id = parsed.Id;
DnsMessage dnsMessage = new DnsMessage(headerBuilder)
{
Answers = answers.ToArray(), Questions = parsed.Questions
};
sending = DateTime.Now.Subtract(start);
udpSock.SendTo(Serializer.Serialize(dnsMessage), _groupEp);
end = DateTime.Now;
ShowWaterfall(start, end, new KeyValuePair <string, TimeSpan>[] { new KeyValuePair <string, TimeSpan>("Recieving", recieving), new KeyValuePair <string, TimeSpan>("Parsing", parsing), new KeyValuePair <string, TimeSpan>("Answering", answering), new KeyValuePair <string, TimeSpan>("Sending", sending) });
}
public void Reslover(string domain)
{
if (Server == "本机直查")
{
try
{
Stopwatch stamp = new Stopwatch();
stamp.Start();
IPAddress[] address = Dns.GetHostAddresses(domain);
stamp.Stop();
foreach (IPAddress i in address)
{
Result += i.ToString() + Environment.NewLine;
}
TimeOut = stamp.ElapsedMilliseconds;
}
catch (Exception e)
{
Result = e.ToString();
}
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Result"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("TimeOut"));
return;
}
Domain = domain;
node.Note("连接DNS服务器..........");
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Domain"));
DnsClient client = new DnsClient(IPAddress.Parse(Server), 1000);
TimeSpan span_begin = new TimeSpan();
node.Note("请求响应......");
DnsMessage message = client.Resolve(new ARSoft.Tools.Net.DomainName(new string[] { domain }), RecordType.Any, RecordClass.INet);
TimeSpan span_end = new TimeSpan();
node.Note("处理结果");
if (message == null)
{
Result = "空结果";
}
else
{
Result = $"共查询到{message.AnswerRecords.Count.ToString()}个记录{message.ReturnCode.ToString()}{Environment.NewLine}";
foreach (DnsRecordBase record in message.AnswerRecords)
{
Result += record.GetType().Name + "记录:";
if (record is ARecord)
{
Result += (record as ARecord).Address.ToString() + Environment.NewLine;
}
else if (record is CNameRecord)
{
Result += (record as CNameRecord).CanonicalName.ToString();
}
else if (record is NaptrRecord)
{
Result += (record as NaptrRecord).Replacement.ToString();
}
else if (record is PtrRecord)
{
Result += (record as PtrRecord).PointerDomainName.ToString();
}
else
{
Result += record.ToString() + Environment.NewLine;
}
}
}
TimeOut = (span_begin - span_end).TotalMilliseconds;
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Result"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("TimeOut"));
}
private string GetKeyName(DnsMessage message)
{
if (message.QuestionCount > 0)
{
return string.Format("{0}|{1}|{2}|{3}", message.QueryIdentifier, message.Questions[0].Class, message.Questions[0].Type, message.Questions[0].Name);
}
else
{
return message.QueryIdentifier.ToString();
}
}
public void Opcode()
{
DnsMessage message = new DnsMessage();
message.QR = true;
Assert.AreEqual(0x8000, message.Flags);
message.Opcode = (byte) OpCode.UPDATE;
Assert.AreEqual((byte) OpCode.UPDATE, message.Opcode);
Assert.AreEqual(0xa800, message.Flags);
}
public void TransitiveQueryTest2()
{
DnsMessage message = new DnsMessage();
message.QueryIdentifier = 0xFEED;
message.QR = false;
message.Opcode = (byte) OpCode.QUERY;
message.AA = false;
message.TC = false;
message.RD = true;
message.RA = false;
message.Zero = false;
message.AuthenticatingData = false;
message.CheckingDisabled = false;
message.RCode = 0x0000;
message.QuestionCount = 1;
message.AnswerCount = 2;
message.NameServerCount = 0;
message.AdditionalCount = 0;
message.Questions = new QuestionList();
message.Questions.Add(new Question {Name = "www.msn.com", Class = ResourceClass.IN, Type = ResourceType.A});
message.Answers.Add(new Resource {Name = "8.8.8.8", Class = ResourceClass.IN, Type = ResourceType.NS, TTL = 468, DataLength = 0, RData = null});
RData data = new ANameRData {Address = IPAddress.Parse("8.8.8.9")};
message.Answers.Add(new Resource {Name = "8.8.8.9", Class = ResourceClass.IN, Type = ResourceType.NS, TTL = 468, RData = data, DataLength = (ushort) data.Length});
DnsMessage outMessage;
using (MemoryStream stream = new MemoryStream())
{
message.WriteToStream(stream);
Assert.IsTrue(DnsMessage.TryParse(stream.GetBuffer(), out outMessage));
}
Assert.AreEqual(0xFEED, outMessage.QueryIdentifier);
Assert.IsFalse(outMessage.QR);
Assert.AreEqual((byte) OpCode.QUERY, outMessage.Opcode);
Assert.IsFalse(outMessage.AA);
Assert.IsFalse(outMessage.TC);
Assert.IsTrue(outMessage.RD);
Assert.IsFalse(outMessage.RA);
Assert.IsFalse(outMessage.Zero);
Assert.IsFalse(outMessage.AuthenticatingData);
Assert.IsFalse(outMessage.CheckingDisabled);
Assert.AreEqual(0x0000, outMessage.RCode);
Assert.AreEqual(0x0001, outMessage.QuestionCount);
Assert.AreEqual(0x0002, outMessage.AnswerCount);
Assert.AreEqual(0x0000, outMessage.NameServerCount);
Assert.AreEqual(0x0000, outMessage.AdditionalCount);
// Question Checks
Assert.AreEqual(outMessage.QuestionCount, outMessage.Questions.Count());
// Q1
Assert.AreEqual("www.msn.com", outMessage.Questions[0].Name);
Assert.AreEqual(ResourceType.A, outMessage.Questions[0].Type);
Assert.AreEqual(ResourceClass.IN, outMessage.Questions[0].Class);
Assert.AreEqual(outMessage.AnswerCount, outMessage.Answers.Count());
Assert.AreEqual(outMessage.AnswerCount, outMessage.Answers.Count());
Assert.AreEqual("8.8.8.8", outMessage.Answers[0].Name);
Assert.AreEqual("8.8.8.9", outMessage.Answers[1].Name);
}
