} // End Function ResolveMessage
static async Task ForwardMessage(DnsMessage query, QueryReceivedEventArgs e, DnsMessage response)
{
if ((query.Questions.Count == 1))
{
// send query to upstream server
DnsQuestion question = query.Questions[0];
DnsMessage upstreamResponse = await s_dnsClient.ResolveAsync(question.Name
, question.RecordType, question.RecordClass
);
e.Response = upstreamResponse;
return;
// 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
private static Task DnsServer_QueryReceived(object sender, QueryReceivedEventArgs eventArgs)
{
eventArgs.Query.IsQuery = false;
DnsMessage query = eventArgs.Query as DnsMessage;
if (query == null || query.Questions.Count <= 0)
{
query.ReturnCode = ReturnCode.ServerFailure;
}
else
{
if (query.Questions[0].RecordType == RecordType.A)
{
foreach (DnsQuestion dnsQuestion in query.Questions)
{
//string resolvedIp = Resolve(clientAddress.ToString(), dnsQuestion.Name);
ARecord aRecord = new ARecord(dnsQuestion.Name, 36000, ipAddress);
query.AnswerRecords.Add(aRecord);
}
}
else
{
return(null);
}
}
eventArgs.Response = eventArgs.Query;
return(Task.CompletedTask);
}
/// <summary>
/// 消息队列处理
/// </summary>
/// <param name="sender"></param>
/// <param name="eventArgs"></param>
/// <returns></returns>
private Task DnsServer_QueryReceived(object sender, QueryReceivedEventArgs eventArgs)
{
return(Task.Run(() =>
{
var message = eventArgs.Query;
var clientAddress = eventArgs.RemoteEndpoint;
message.IsQuery = false;
DnsMessage query = message as DnsMessage;
if (query == null || query.Questions.Count <= 0)
{
message.ReturnCode = ReturnCode.ServerFailure;
}
else
{
if (query.Questions[0].RecordType == RecordType.A)
{
foreach (DnsQuestion dnsQuestion in query.Questions)
{
string resolvedIp = Resolve(clientAddress.ToString(), dnsQuestion.Name.ToString());
ARecord aRecord = new ARecord(query.Questions[0].Name, 36000, IPAddress.Parse(resolvedIp));
query.AnswerRecords.Add(aRecord);
}
}
}
eventArgs.Response = message;
}));
}
private async Task OnQueryReceived(object sender, QueryReceivedEventArgs e)
{
DnsMessage message = e.Query as DnsMessage;
DnsMessage query = e.Query as DnsMessage;
if (query == null)
{
return;
}
if (message.Questions.Count != 1)
{
return;
}
var question = query.Questions[0];
_logger.LogInformation("dns-req: {0} {1}", question.RecordType, question.Name);
DnsMessage response = query.CreateResponseInstance();
var domainsToAnswerDirect = new[] { _cfg.VtunerServerOne, _cfg.VtunerServerTwo }
.Select(x => ARSoft.Tools.Net.DomainName.Parse(x))
.ToList();
if (question.RecordType == RecordType.A
//&& question.Name.IsSubDomainOf(ARSoft.Tools.Net.DomainName.Parse("vtuner.com"))
&& domainsToAnswerDirect.Any(x => x == question.Name))
{
var myIp = _networkInterfaceHelper.GetMyIPv4Address();
response.AnswerRecords.Add(new ARecord(question.Name, 10, myIp));
response.ReturnCode = ReturnCode.NoError;
// set the response
e.Response = response;
return;
}
// send query to upstream server
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);
}
foreach (DnsRecordBase record in (upstreamResponse.AdditionalRecords))
{
response.AdditionalRecords.Add(record);
}
response.ReturnCode = ReturnCode.NoError;
// set the response
e.Response = response;
}
}
private async Task OnQueryReceived(object sender, QueryReceivedEventArgs e)
{
try
{
if (e.Query is DnsMessage message &&
message.Questions.Count == 1)
{
var upstreamResponse =
await DoQuery(message, e.RemoteEndpoint.Address.ToString()).ConfigureAwait(false);
if (upstreamResponse != null)
{
upstreamResponse.ReturnCode = ReturnCode.NoError;
e.Response = upstreamResponse;
}
}
await Task.CompletedTask.ConfigureAwait(false);
}
catch (ArgumentNullException ane)
{
HandleArgumentNullException(ane);
await Task.FromException(ane).ConfigureAwait(false);
}
catch (ArgumentOutOfRangeException aoore)
{
HandleArgumentOutOfRangeException(aoore);
await Task.FromException(aoore).ConfigureAwait(false);
}
catch (Exception exception)
{
HandleException(exception);
await Task.FromException(exception).ConfigureAwait(false);
}
}
} // End Function OnClientConnected
private static async Task OnQueryReceived(object sender, QueryReceivedEventArgs e)
{
DnsMessage query = e.Query as DnsMessage;
if (query == null)
{
return;
}
// e.RemoteEndpoint.Address
DnsMessage response = query.CreateResponseInstance();
// check for valid query
if ((query.Questions.Count == 1) &&
(query.Questions[0].RecordType == RecordType.Txt) &&
(query.Questions[0].Name.Equals(ARSoft.Tools.Net.DomainName.Parse("example.com"))))
{
response.ReturnCode = ReturnCode.NoError;
response.AnswerRecords.Add(new TxtRecord(ARSoft.Tools.Net.DomainName.Parse("example.com"), 3600, "Hello world"));
}
else
{
response.ReturnCode = ReturnCode.ServerFailure;
}
// set the response
e.Response = response;
} // End Function OnQueryReceived
private async Task OnQueryReceived(object sender, QueryReceivedEventArgs e)
{
var query = e.Query as DnsMessage;
if (query == null)
{
return;
}
var response = query.CreateResponseInstance();
foreach (var question in query.Questions)
{
var dnsMessage = await _dnsManager.ResolveAsync(question);
if ((dnsMessage == null) || ((dnsMessage.ReturnCode != ReturnCode.NoError) && (dnsMessage.ReturnCode != ReturnCode.NxDomain)))
{
response.ReturnCode = ReturnCode.ServerFailure;
return;
}
foreach (var dnsRecord in dnsMessage.AnswerRecords)
{
response.AnswerRecords.Add(dnsRecord);
}
response.AuthorityRecords.AddRange(dnsMessage.AuthorityRecords);
}
//var domain = query.Questions[0].Name.ToString();
//var dnsMessage = DnsClient.Default.Resolve(DomainName.Parse(domain), RecordType.A);
//response.ReturnCode = ReturnCode.ServerFailure;
e.Response = response;
}
private async Task ServerOnQueryReceived(object sender, QueryReceivedEventArgs eventargs)
{
if (!(eventargs.Query is DnsMessage dnsMessage))
{
return;
}
var isBlacklisted = IsBlacklisted(dnsMessage);
var response = await _client.SendMessageAsync(dnsMessage);
if (!isBlacklisted)
{
eventargs.Response = response;
}
else
{
var newMessage = ReplaceARecords(response, dnsMessage);
eventargs.Response = newMessage;
}
if (_isService)
{
return;
}
#pragma warning disable 4014
LogQuery(dnsMessage, (DnsMessage)eventargs.Response, isBlacklisted);
#pragma warning restore 4014
}
} // End Function OnClientConnected
// nslookup somewhere.com some.dns.server
// nslookup somewhere.com 127.0.0.1
static async Task OnQueryReceived(object sender, QueryReceivedEventArgs e)
{
// if (!IPAddress.IsLoopback(e.RemoteEndpoint.Address))
DnsMessage query = e.Query as DnsMessage;
if (query == null)
{
return;
}
DnsMessage response = query.CreateResponseInstance();
if ((query.Questions.Count < 1))
{
response.ReturnCode = ReturnCode.NoError;
return;
} // End if ((query.Questions.Count < 1))
if (!await ResolveMessage(query, e, response))
{
await ForwardMessage(query, e, response);
}
// set the response
// e.Response = response;
} // End Function OnQueryReceived
private static async Task OnQueryReceived(object sender, QueryReceivedEventArgs e)
{
var message = e.Query as DnsMessage;
var response = message?.CreateResponseInstance();
if (message?.Questions.Count == 1)
{
// send query to upstream _servers
var question = message.Questions[0];
var 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 (var record in (upstreamResponse.AnswerRecords))
{
response.AnswerRecords.Add(record);
}
foreach (var record in (upstreamResponse.AdditionalRecords))
{
response.AdditionalRecords.Add(record);
}
response.ReturnCode = ReturnCode.NoError;
// set the response
e.Response = response;
}
}
}
private Task OnQueryReceived(object sender, QueryReceivedEventArgs e)
{
var query = (DnsMessage)e.Query;
query.IsQuery = false;
var question = query.Questions.First();
var clientEndPoint = e.RemoteEndpoint;
var accessAllowed = IsAccessAllowed(clientEndPoint, question);
if (!accessAllowed)
{
return(Task.FromResult(1));
}
var answer = ResolveDnsQuery(question);
if (IsRedicted(question))
{
// Resolved with redirection
SetupReponse(query, question);
if (_portForwardingManager != null)
{
SetupForwarding(answer);
}
e.Response = query;
return(Task.FromResult(0));
}
if (query.Questions.Count == 1 && answer != null)
{
foreach (var record in answer.AnswerRecords)
{
query.AnswerRecords.Add(record);
}
foreach (var record in answer.AdditionalRecords)
{
query.AnswerRecords.Add(record);
}
// Resolved without redirection
query.ReturnCode = ReturnCode.NoError;
e.Response = query;
return(Task.FromResult(0));
}
// Failed to resolve ...
query.ReturnCode = ReturnCode.ServerFailure;
e.Response = query;
return(Task.FromResult(0));
}
private async Task OnDnsQueryReceived(QueryReceivedEventArgs e, IEnumerable <DomainName> domains)
{
DnsMessage message = e.Query as DnsMessage;
if (message == null || message.Questions.Count != 1)
{
return;
}
DnsQuestion question = message.Questions[0];
DnsMessage response = message.CreateResponseInstance();
//If domain match return localhost
if ((Program.Options.Ncsi && question.Name.Equals(_ncsiDomain)) || domains.Any(x => x.Equals(question.Name)))
{
if (question.RecordType == RecordType.A)
{
response.ReturnCode = ReturnCode.NoError;
response.AnswerRecords.Add(new ARecord(question.Name, 10, IPAddress.Loopback));
}
else if (question.RecordType == RecordType.Aaaa)
{
response.ReturnCode = ReturnCode.NoError;
response.AnswerRecords.Add(new AaaaRecord(question.Name, 10, IPAddress.IPv6Loopback));
}
}
else if (_upStreamDnsClient != null)
{
// send query to upstream server
DnsMessage upstreamResponse = await _upStreamDnsClient.ResolveAsync(question.Name, question.RecordType, question.RecordClass);
if (upstreamResponse == null)
{
return;
}
// if got an answer, copy it to the message sent to the client
response.AnswerRecords.AddRange(upstreamResponse.AnswerRecords);
response.AdditionalRecords.AddRange(upstreamResponse.AdditionalRecords);
response.ReturnCode = upstreamResponse.ReturnCode;
}
// set the response
e.Response = response;
if (response.AnswerRecords.Count != 0)
{
Logging.WriteVerbose("DNS Response: {0}", response.AnswerRecords.FirstOrDefault());
}
else
{
Logging.WriteVerbose("DNS Response: Can not find {0} records for {1}", question.RecordType.ToString().ToUpperInvariant(), question.Name);
}
}
static async Task OnQueryReceived(object sender, QueryReceivedEventArgs e)
{
DnsMessage query = e.Query as DnsMessage;
if (query == null)
{
return;
}
DnsMessage response = query.CreateResponseInstance();
foreach (var question in query.Questions)
{
//Console.WriteLine(question.Name.ToString());
DnsMessage upstreamResponse;
Boolean useDefault = true;
foreach (var domain in domains)
{
if (question.Name.ToString().ToLower().Contains(domain))
{
useDefault = false;
}
}
if (useDefault)
{
upstreamResponse = await defaultClient.ResolveAsync(question.Name, question.RecordType, question.RecordClass);
}
else
{
upstreamResponse = await netflixClient.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;
e.Response = response;
}
}
}
private async Task DnsServer_QueryReceived(object sender, QueryReceivedEventArgs eventArgs)
{
DnsMessage message = eventArgs.Query as DnsMessage;
if (message == null)
{
return;
}
DnsMessage response = message.CreateResponseInstance();
if ((message.Questions.Count == 1))
{
DnsQuestion question = message.Questions[0];
var fullAddress = string.Join(".", question.Name.Labels);
if (this.blockedList.Contains(fullAddress))
{
ARecord fakeRecord = new ARecord(question.Name, 10, this.loopbackIpAddress);
response.ReturnCode = ReturnCode.NoError;
Debug.WriteLine("Blocked: " + fullAddress);
eventArgs.Response = response;
return;
}
// send query to upstream server
DnsMessage upstreamResponse = await this.dnsClient.ResolveAsync(question.Name, question.RecordType, question.RecordClass);
var answer = upstreamResponse.AnswerRecords.FirstOrDefault();
// if got an answer, copy it to the message sent to the client
if (answer != 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;
}
}
}
async Task OnQueryReceived(object sender, QueryReceivedEventArgs eventArgs)
{
DnsMessage query = eventArgs.Query as DnsMessage;
DnsMessage response = null;
if (query == null)
{
return;
}
response = await umleitung_process_request(query);
eventArgs.Response = response;
}
private async Task OnDnsOnQueryReceived(object sender, QueryReceivedEventArgs e)
{
try
{
if (!(e.Query is DnsMessage query))
{
return;
}
e.Response = await new DnsClient(TargetIp, 1000).SendMessageAsync(query);
}
catch (Exception exception)
{
Console.WriteLine(exception);
}
}
#pragma warning disable CS1998 // 异步方法缺少 "await" 运算符，将以同步方式运行
static async Task OnQueryReceived(object sender, QueryReceivedEventArgs e)
#pragma warning restore CS1998 // 异步方法缺少 "await" 运算符，将以同步方式运行
{
DnsMessage query = e.Query as DnsMessage;
if (query == null)
{
return;
}
DnsMessage response = query.CreateResponseInstance();
if (query.Questions.Count == 1)
{
if (query.Questions[0].RecordType == RecordType.A)
{
string url = query.Questions[0].Name.ToString();
ObjectCache oc = MemoryCache.Default;
string ips = oc[url] as string;
if (ips == null)
{
CacheItemPolicy cip = new CacheItemPolicy();
cip.AbsoluteExpiration = DateTime.Now.AddMinutes(10);
HttpClient client = new HttpClient();
var responseString = client.GetStringAsync("http://119.29.29.29/d?dn=" + url);
ips = responseString.Result;
oc.Set(url, ips, cip);
}
if (ips != "")
{
response.ReturnCode = ReturnCode.NoError;
var Allip = ips.Split(';');
for (int i = 0; i < Allip.Count(); i++)
{
response.AnswerRecords.Add(new ARecord(DomainName.Parse(url), 600, IPAddress.Parse(Allip[i])));
}
}
else
{
response.ReturnCode = ReturnCode.ServerFailure;
}
}
else
{
response.ReturnCode = ReturnCode.ServerFailure;
}
}
e.Response = response;
}
static async Task OnQueryReceived(object sender, QueryReceivedEventArgs e)
{
DnsMessage query = e.Query as DnsMessage;
LogToThreadLockedConsole(string.Format("--> DNS query recieved from {0} for {1} (Type: {2})",
e.RemoteEndpoint,
query.Questions[0].Name,
query.Questions[0].RecordType),
ConsoleColor.Green, true);
if (query == null)
{
return;
}
DnsMessage response = query.CreateResponseInstance();
DnsQuestion question = response.Questions[0];
if (IsAllowed(question.Name.ToString()))
{
DnsClient client = new DnsClient(IPAddress.Parse("208.67.222.222"), 5000); // This is the IP for OpenDNS
DnsMessage upstreamResponse = await client.ResolveAsync(question.Name, question.RecordType, question.RecordClass);
List <string> recordsRecieved = new List <string>();
foreach (DnsRecordBase record in upstreamResponse.AnswerRecords)
{
response.AnswerRecords.Add(record);
if (!recordsRecieved.Contains(record.Name.ToString() + "|" + record.RecordType.ToString() + "|" + record.RecordType.ToString()))
{
if (record.RecordType.ToString().ToUpper() != "OPT")
{
LogToThreadLockedConsole(string.Format("<-- Response from upstream: {0} (Type: {1})", record.Name, record.RecordType), ConsoleColor.Gray, true);
recordsRecieved.Add(record.Name.ToString() + "|" + record.RecordType.ToString() + "|" + record.RecordType.ToString());
}
}
}
}
response.ReturnCode = ReturnCode.NoError;
e.Response = response;
}
private static async Task OnQueryReceived(object sender, QueryReceivedEventArgs e)
{
var message = e.Query as DnsMessage;
var response = message?.CreateResponseInstance();
if (message?.Questions.Count == 1)
{
// send query to upstream _servers
var question = message.Questions[0];
DnsClient client = DnsClient.Default;
if (FORCE_IPV4)
{
Random rand = new Random();
var ipv4DnsServers = DnsClient.GetLocalConfiguredDnsServers().Where(a => a.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork);
var list = ipv4DnsServers.OrderBy(a => rand.Next()).ToList();
client = new DnsClient(list, DnsClient.Default.QueryTimeout);
}
var upstreamResponse =
await client.ResolveAsync(question.Name, question.RecordType, question.RecordClass);
// if got an answer, copy it to the message sent to the client
if (upstreamResponse != null)
{
foreach (var record in (upstreamResponse.AnswerRecords))
{
response.AnswerRecords.Add(record);
}
foreach (var record in (upstreamResponse.AdditionalRecords))
{
response.AdditionalRecords.Add(record);
}
response.ReturnCode = ReturnCode.NoError;
// set the response
e.Response = response;
}
}
}
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;
}
} // 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
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));
}
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 async Task OnQueryReceived(object sender, QueryReceivedEventArgs e)
{
DnsMessage message = e.Query as DnsMessage;
DnsMessage query = e.Query as DnsMessage;
if (query == null)
{
return;
}
DnsMessage response = query.CreateResponseInstance();
if (e.RemoteEndpoint.Address == null)
{
return;
}
string ipAdr = e.RemoteEndpoint.Address.ToString();
Client client = dc.Clients.SingleOrDefault(c => c.Ip == ipAdr);
if (client == null)
{
dc.Clients.Add(new Client()
{
Ip = ipAdr
});
dc.SaveChanges();
}
if ((message.Questions.Count == 1))
{
DnsQuestion question = message.Questions[0];
if (client.IsBlocked)
{
dc.Logs.Add(new Log()
{
ClientIp = ipAdr, Request = question.Name.ToString(), Result = Log.ResultType.success
});
dc.SaveChanges();
return;
}
DnsClient dnsClient = new DnsClient(IPAddress.Parse(mainDns), 5000);
DnsMessage upstreamResponse = await dnsClient.ResolveAsync(question.Name, question.RecordType, question.RecordClass);
if (globalBlock == "1")
{
response.AnswerRecords.AddRange(
upstreamResponse.AnswerRecords
.Where(w => !(w is ARecord))
.Concat(
upstreamResponse.AnswerRecords
.OfType <ARecord>()
.Select(a => new ARecord(a.Name, a.TimeToLive, IPAddress.Parse(globalBlockIp)))
)
);
dc.Logs.Add(new Log()
{
ClientIp = ipAdr, Request = question.Name.ToString(), Result = Log.ResultType.blocked
});
dc.SaveChanges();
}
else
{
string questionUrl = question.Name.ToString();
Domain questionDomain = domainList.SingleOrDefault(d => questionUrl.Contains(d.Url));
if (questionDomain == null)
{
if (upstreamResponse.AnswerRecords[0] != 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;
dc.Logs.Add(new Log()
{
ClientIp = ipAdr, Request = question.Name.ToString(), Result = Log.ResultType.success
});
dc.SaveChanges();
}
}
else
{
if (questionDomain.Type == Data.DType.blocked)
{
response.AnswerRecords.AddRange(
upstreamResponse.AnswerRecords
.Where(w => !(w is ARecord))
.Concat(
upstreamResponse.AnswerRecords
.OfType <ARecord>()
.Select(a => new ARecord(a.Name, a.TimeToLive, IPAddress.Parse(globalBlockIp)))
)
);
dc.Logs.Add(new Log()
{
ClientIp = ipAdr, Request = question.Name.ToString(), Result = Log.ResultType.blocked
});
dc.SaveChanges();
}
else
{
response.AnswerRecords.AddRange(
upstreamResponse.AnswerRecords
.Where(w => !(w is ARecord))
.Concat(
upstreamResponse.AnswerRecords
.OfType <ARecord>()
.Select(a => new ARecord(a.Name, a.TimeToLive, IPAddress.Parse(questionDomain.ForwardIp)))
)
);
dc.Logs.Add(new Log()
{
ClientIp = ipAdr, Request = question.Name.ToString(), Result = Log.ResultType.forward
});
dc.SaveChanges();
}
}
}
e.Response = response;
}
}
private async Task OnQueryReceived(object sender, QueryReceivedEventArgs e)
{
if (e.Query is DnsMessage message)
{
var response = message.CreateResponseInstance();
if (message.Questions.Count == 1)
{
DnsClient dnsClient;
var options = new DnsQueryOptions
{
IsEDnsEnabled = true,
IsRecursionDesired = message.IsRecursionDesired,
IsDnsSecOk = message.IsDnsSecOk,
IsCheckingDisabled = message.IsCheckingDisabled
};
var existEcs = ExistEcs(message.EDnsOptions);
if (existEcs)
{
foreach (var option in message.EDnsOptions.Options)
{
options.EDnsOptions.Options.Add(option);
}
}
var question = message.Questions[0];
Console.WriteLine($@"DNS query: {question.Name}");
if (IsLocal(question.Name))
{
response.ReturnCode = ReturnCode.NxDomain;
e.Response = response;
return;
}
else if (IsOnList(question.Name))
{
dnsClient = UpStreamDns;
if (!existEcs)
{
if (UpStreamEcs != null)
{
options.EDnsOptions.Options.Add(UpStreamEcs);
}
else //if (question.RecordType != RecordType.Ptr)
{
options.EDnsOptions.Options.Add(new ClientSubnetOption(32, e.RemoteEndpoint.Address));
}
}
}
else
{
dnsClient = PureDns;
if (!existEcs)
{
if (PureEcs != null)
{
options.EDnsOptions.Options.Add(PureEcs);
}
else //if (question.RecordType != RecordType.Ptr)
{
options.EDnsOptions.Options.Add(new ClientSubnetOption(32, e.RemoteEndpoint.Address));
}
}
}
// send query to upstream server
var upstreamResponse = await dnsClient.ResolveAsync(question.Name, question.RecordType, question.RecordClass, options);
// if got an answer, copy it to the message sent to the client
if (upstreamResponse != null)
{
upstreamResponse.TransactionID = response.TransactionID;
if (!existEcs)
{
upstreamResponse.EDnsOptions = response.EDnsOptions;
}
response = upstreamResponse;
response.ReturnCode = ReturnCode.NoError;
e.Response = response;
}
}
else
{
response.ReturnCode = ReturnCode.FormatError;
e.Response = response;
}
}
}
public static async Task ServerOnQueryReceived(object sender, QueryReceivedEventArgs e)
{
try
{
if (!(e.Query is DnsMessage query))
{
return;
}
IPAddress clientAddress = e.RemoteEndpoint.Address;
if (DnsSettings.EDnsCustomize)
{
clientAddress = Equals(DnsSettings.EDnsIp, IPAddress.Parse("0.0.0.1"))
? IPAddress.Parse(MainWindow.IntIPAddr.ToString().Substring(
0, MainWindow.IntIPAddr.ToString().LastIndexOf(".", StringComparison.Ordinal)) + ".1") : DnsSettings.EDnsIp;
}
else if (Equals(clientAddress, IPAddress.Loopback) || IpTools.InSameLaNet(clientAddress, MainWindow.LocIPAddr))
{
clientAddress = MainWindow.IntIPAddr;
}
DnsMessage response = query.CreateResponseInstance();
if (query.Questions.Count <= 0)
{
response.ReturnCode = ReturnCode.ServerFailure;
}
else
{
foreach (DnsQuestion dnsQuestion in query.Questions)
{
response.ReturnCode = ReturnCode.NoError;
if (DnsSettings.DebugLog)
{
BackgroundLog($@"| {DateTime.Now} {e.RemoteEndpoint.Address} : {dnsQuestion.Name} | {dnsQuestion.RecordType.ToString().ToUpper()}");
}
if (DomainName.Parse(new Uri(DnsSettings.HttpsDnsUrl).DnsSafeHost) == dnsQuestion.Name ||
DomainName.Parse(new Uri(DnsSettings.SecondHttpsDnsUrl).DnsSafeHost) == dnsQuestion.Name ||
DomainName.Parse(new Uri(UrlSettings.WhatMyIpApi).DnsSafeHost) == dnsQuestion.Name)
{
if (!DnsSettings.StartupOverDoH)
{
response.AnswerRecords.AddRange((await new DnsClient(DnsSettings.SecondDnsIp, 5000)
.ResolveAsync(dnsQuestion.Name, dnsQuestion.RecordType)).AnswerRecords);
if (DnsSettings.DebugLog)
{
BackgroundLog($"| -- Startup SecondDns : {DnsSettings.SecondDnsIp}");
}
}
else
{
response.AnswerRecords.AddRange(ResolveOverHttpsByDnsJson(clientAddress.ToString(),
dnsQuestion.Name.ToString(), "https://1.0.0.1/dns-query", DnsSettings.ProxyEnable,
DnsSettings.WProxy, dnsQuestion.RecordType).list);
if (DnsSettings.DebugLog)
{
BackgroundLog("| -- Startup DoH : https://1.0.0.1/dns-query");
}
}
}
else if (DnsSettings.DnsCacheEnable && DnsCache.Contains(query))
{
response.AnswerRecords.AddRange(DnsCache.Get(query).AnswerRecords);
//response.AnswerRecords.Add(new TxtRecord(DomainName.Parse("cache.auroradns.mili.one"), 0,
// "AuroraDNSC Cached"));
if (DnsSettings.DebugLog)
{
BackgroundLog(
$@"|- CacheContains : {dnsQuestion.Name} | Count : {MemoryCache.Default.Count()}");
}
}
else if (DnsSettings.BlackListEnable && DnsSettings.BlackList.Contains(dnsQuestion.Name))
{
response.AnswerRecords.Add(new ARecord(dnsQuestion.Name, 10, IPAddress.Any));
response.AnswerRecords.Add(new TxtRecord(DomainName.Parse("blacklist.auroradns.mili.one"), 0,
"AuroraDNSC Blocked"));
if (DnsSettings.DebugLog)
{
BackgroundLog(@"|- BlackList");
}
}
else if (DnsSettings.WhiteListEnable && DnsSettings.WhiteList.ContainsKey(dnsQuestion.Name))
{
List <DnsRecordBase> whiteRecords = new List <DnsRecordBase>();
if (!IpTools.IsIp(DnsSettings.WhiteList[dnsQuestion.Name]))
{
whiteRecords.AddRange((await new DnsClient(DnsSettings.SecondDnsIp, 5000)
.ResolveAsync(dnsQuestion.Name, dnsQuestion.RecordType)).AnswerRecords);
}
else
{
whiteRecords.Add(new ARecord(dnsQuestion.Name, 10,
IPAddress.Parse(DnsSettings.WhiteList[dnsQuestion.Name])));
}
response.AnswerRecords.AddRange(whiteRecords);
response.AnswerRecords.Add(new TxtRecord(DomainName.Parse("whitelist.auroradns.mili.one"), 0,
"AuroraDNSC Rewrote"));
if (DnsSettings.DebugLog)
{
BackgroundLog(@"|- WhiteList");
}
}
else if (DnsSettings.ChinaListEnable && DomainNameInChinaList(dnsQuestion.Name))
{
try
{
var resolvedDnsList = ResolveOverHttpByDPlus(dnsQuestion.Name.ToString());
if (resolvedDnsList != null && resolvedDnsList != new List <DnsRecordBase>())
{
resolvedDnsList.Add(new TxtRecord(DomainName.Parse("chinalist.auroradns.mili.one"),
0, "AuroraDNSC ChinaList - DNSPod D+"));
foreach (var item in resolvedDnsList)
{
response.AnswerRecords.Add(item);
}
if (DnsSettings.DebugLog)
{
BackgroundLog(@"|- ChinaList - DNSPOD D+");
}
if (DnsSettings.DnsCacheEnable && response.ReturnCode == ReturnCode.NoError)
{
BackgroundWriteCache(response);
}
}
}
catch (Exception exception)
{
BackgroundLog(exception.ToString());
}
}
else
{
//Resolve
try
{
(List <DnsRecordBase> resolvedDnsList, ReturnCode statusCode) = DnsSettings.DnsMsgEnable
? ResolveOverHttpsByDnsMsg(clientAddress.ToString(),
dnsQuestion.Name.ToString(), DnsSettings.HttpsDnsUrl, DnsSettings.ProxyEnable,
DnsSettings.WProxy, dnsQuestion.RecordType)
: ResolveOverHttpsByDnsJson(clientAddress.ToString(),
dnsQuestion.Name.ToString(), DnsSettings.HttpsDnsUrl, DnsSettings.ProxyEnable,
DnsSettings.WProxy, dnsQuestion.RecordType);
if (resolvedDnsList != null && resolvedDnsList.Count != 0 && statusCode == ReturnCode.NoError)
{
response.AnswerRecords.AddRange(resolvedDnsList);
if (DnsSettings.DnsCacheEnable)
{
BackgroundWriteCache(response);
}
}
else if (statusCode == ReturnCode.ServerFailure)
{
response.AnswerRecords = (await new DnsClient(DnsSettings.SecondDnsIp, 1000)
.ResolveAsync(dnsQuestion.Name, dnsQuestion.RecordType)).AnswerRecords;
BackgroundLog($"| -- SecondDns : {DnsSettings.SecondDnsIp}");
}
else
{
response.ReturnCode = statusCode;
}
}
catch (Exception ex)
{
response.ReturnCode = ReturnCode.ServerFailure;
BackgroundLog(@"| " + ex);
}
}
}
}
if (DnsSettings.TtlRewrite &&
response.AnswerRecords.All(item => item.Name != DomainName.Parse("cache.auroradns.mili.one")))
{
var list = response.AnswerRecords.Where(item =>
item.TimeToLive < DnsSettings.TtlMinTime - DateTime.Now.Second).ToList();
foreach (var item in list)
{
switch (item)
{
case ARecord aRecord:
response.AnswerRecords.Add(
new ARecord(aRecord.Name, DnsSettings.TtlMinTime, aRecord.Address));
response.AnswerRecords.Remove(item);
break;
case AaaaRecord aaaaRecord:
response.AnswerRecords.Add(
new ARecord(aaaaRecord.Name, DnsSettings.TtlMinTime, aaaaRecord.Address));
response.AnswerRecords.Remove(item);
break;
case CNameRecord cNameRecord:
response.AnswerRecords.Add(new CNameRecord(cNameRecord.Name, DnsSettings.TtlMinTime,
cNameRecord.CanonicalName));
response.AnswerRecords.Remove(item);
break;
}
}
if (list.Count > 0)
{
response.AnswerRecords.Add(new TxtRecord(DomainName.Parse("ttl.auroradns.mili.one"), 600,
$"Rewrite TTL to {DnsSettings.TtlMinTime}"));
}
}
e.Response = response;
}
catch (Exception exception)
{
Console.WriteLine(exception);
BackgroundLog(exception.ToString());
}
}
} // End Function OnClientConnected
static async Task OnQueryReceived(object sender, QueryReceivedEventArgs e)
{
// process query as you like
} // End Function OnQueryReceived
private static async Task OnQueryReceived(object sender, QueryReceivedEventArgs e)
{
DnsMessage query = e.Query as DnsMessage;
if (query == null)
{
return;
}
// https://en.wikipedia.org/wiki/Domain_Name_System_Security_Extensions
DnsMessage response = query.CreateResponseInstance();
// https://tools.ietf.org/html/rfc3658
// https://www.dynu.com/Resources/DNS-Records/DS-Record
response.AnswerRecords.Add(
new DsRecord(
DomainName.Parse("example.com") // Name: It defines the hostname of a record and whether the hostname will be appended to the label.
// Fully qualified hostnames terminated by a period will not append the origin.
, RecordClass.Any
, 60 // ttl The time-to-live in seconds. It specifies how long a resolver is supposed to cache or remember the DNS query
// before the query expires and a new one needs to be done.
, 0 // Key Tag: A short numeric value which can help quickly identify the referenced DNSKEY-record.
, DnsSecAlgorithm.RsaSha256 // The algorithm of the referenced DNSKEY-record.
, DnsSecDigestType.Sha256 // Digest Type: Cryptographic hash algorithm used to create the Digest value.
, new byte[] { 1, 2, 3 } // A cryptographic hash value of the referenced DNSKEY-record.
)
);
// https://tools.ietf.org/html/rfc4034
// https://www.dynu.com/Resources/DNS-Records/DNSKEY-Record
response.AnswerRecords.Add(
new DnsKeyRecord(
DomainName.Parse("example.com") // Name: It defines the hostname of a record and whether the hostname will be appended to the label.
// Fully qualified hostnames terminated by a period will not append the origin.
, RecordClass.Any
, 60 // ttl The time-to-live in seconds. It specifies how long a resolver is supposed to cache or remember the DNS query
// before the query expires and a new one needs to be done.
, DnsKeyFlags.Zone
, 3 // Fixed value of 3 (for backwards compatibility)
, DnsSecAlgorithm.RsaSha256 // The public key's cryptographic algorithm.
, new byte[] { 1, 2, 3 } // Public key data.
)
);
// https://simpledns.plus/help/rrsig-records
// https://simpledns.plus/help/definition-ttl-time-to-live
// https://de.wikipedia.org/wiki/RRSIG_Resource_Record
response.AnswerRecords.Add(
new RrSigRecord(
DomainName.Parse("example.com") // Name of the digitally signed RRs
, RecordClass.Any
, 60 // ttl The time-to-live in seconds. It specifies how long a resolver is supposed to cache or remember the DNS query
// before the query expires and a new one needs to be done.
, RecordType.A // Type Covered: DNS record type that this signature covers.
, DnsSecAlgorithm.RsaSha256 // Cryptographic algorithm used to create the signature.
, 4 // Labels: Number of labels in the original RRSIG-record name (used to validate wildcards).
, 0 // Original TTL: TTL value of the covered record set.
, DateTime.Now.AddMinutes(1) // Signature Expiration: When the signature expires.
, DateTime.Now // Signature Inception: When the signature was created.
, 0 // Key Tag: A short numeric value which can help quickly identify the DNSKEY-record which can be used to validate this signature.
// identifiziert den unterzeichnenden DNSKEY, um zwischen mehreren Signaturen zu unterscheiden (engl. key tag)
, DomainName.Parse("example.com") // Signer's Name: Name of the DNSKEY-record which can be used to validate this signature.
, new byte[] { 1, 2, 3 } // Signature: Cryptographic signature. (Base64)
)
);
// check for valid query
if ((query.Questions.Count == 1) &&
(query.Questions[0].RecordType == RecordType.Txt) &&
(query.Questions[0].Name.Equals(DomainName.Parse("example.com"))))
{
response.ReturnCode = ReturnCode.NoError;
response.AnswerRecords.Add(new TxtRecord(DomainName.Parse("example.com"), 3600, "Hello world"));
}
else
{
response.ReturnCode = ReturnCode.ServerFailure;
}
// set the response
e.Response = response;
} // End Function OnQueryReceived
public static async Task ServerOnQueryReceived(object sender, QueryReceivedEventArgs e)
{
if (!(e.Query is DnsMessage query))
{
return;
}
IPAddress clientAddress = e.RemoteEndpoint.Address;
if (DnsSettings.EDnsCustomize)
{
clientAddress = Equals(DnsSettings.EDnsIp, IPAddress.Parse("0.0.0.1"))
? IPAddress.Parse(MainWindow.IntIPAddr.ToString().Substring(
0, MainWindow.IntIPAddr.ToString().LastIndexOf(".", StringComparison.Ordinal)) + ".0") : DnsSettings.EDnsIp;
}
else if (Equals(clientAddress, IPAddress.Loopback) || IpTools.InSameLaNet(clientAddress, MainWindow.LocIPAddr))
{
clientAddress = MainWindow.IntIPAddr;
}
DnsMessage response = query.CreateResponseInstance();
if (query.Questions.Count <= 0)
{
response.ReturnCode = ReturnCode.ServerFailure;
}
else
{
foreach (DnsQuestion dnsQuestion in query.Questions)
{
response.ReturnCode = ReturnCode.NoError;
if (DnsSettings.DebugLog)
{
BgwLog($@"| {DateTime.Now} {e.RemoteEndpoint.Address} : {dnsQuestion.Name} | {dnsQuestion.RecordType.ToString().ToUpper()}");
}
if (DnsSettings.BlackListEnable && BlackList.Contains(dnsQuestion.Name) && dnsQuestion.RecordType == RecordType.A)
{
//BlackList
ARecord blackRecord = new ARecord(dnsQuestion.Name, 10, IPAddress.Any);
response.AnswerRecords.Add(blackRecord);
if (DnsSettings.DebugLog)
{
BgwLog(@"|- BlackList");
}
}
else if (DnsSettings.WhiteListEnable && WhiteList.ContainsKey(dnsQuestion.Name) && dnsQuestion.RecordType == RecordType.A)
{
//WhiteList
ARecord blackRecord = new ARecord(dnsQuestion.Name, 10, WhiteList[dnsQuestion.Name]);
response.AnswerRecords.Add(blackRecord);
if (DnsSettings.DebugLog)
{
BgwLog(@"|- WhiteList");
}
}
else
{
//Resolve
try
{
var(resolvedDnsList, statusCode) = ResolveOverHttps(clientAddress.ToString(),
dnsQuestion.Name.ToString(), DnsSettings.ProxyEnable, DnsSettings.WProxy, dnsQuestion.RecordType);
if (resolvedDnsList != null && resolvedDnsList != new List <dynamic>() && statusCode == ReturnCode.NoError)
{
foreach (var item in resolvedDnsList)
{
response.AnswerRecords.Add(item);
}
}
else if (statusCode == ReturnCode.ServerFailure)
{
response.AnswerRecords = new DnsClient(DnsSettings.SecondDnsIp, 1000)
.Resolve(dnsQuestion.Name, dnsQuestion.RecordType).AnswerRecords;
BgwLog($"| -- SecondDns {DnsSettings.SecondDnsIp}");
}
else
{
response.ReturnCode = statusCode;
}
}
catch (Exception ex)
{
response.ReturnCode = ReturnCode.ServerFailure;
BgwLog(@"| " + ex);
}
}
}
}
e.Response = response;
}
