/// <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); }