/// <summary>
/// Initializes a new instance of the <see cref="IPAddressRange"/> class.
/// </summary>
/// <param name="cidr">
/// An IP network that represents a starting IP and a subnet in a CIDR notation.
/// </param>
public IPAddressRange(IPNetwork cidr)
{
if (cidr == null)
{
throw new ArgumentNullException("cidr");
}
m_addressFamily = cidr.FirstUsable.AddressFamily;
m_lowerBytes = cidr.FirstUsable.GetAddressBytes();
m_upperBytes = cidr.LastUsable.GetAddressBytes();
}
protected override void BecauseOf()
{
m_result = new IPNetwork(Value, PrefixLength);
}
private static bool TryParseIPNetwork(string ip, CidrParseEnum cidrParseEnum, byte cidr, out IPNetwork ipn) {
IPNetwork ipnetwork = null;
if (cidrParseEnum == CidrParseEnum.Default) {
if (!IPNetwork.TryParse(ip, out ipnetwork)) {
ipn = null;
return false;
}
}
else if (cidrParseEnum == CidrParseEnum.Value) {
if (!IPNetwork.TryParse(ip, cidr, out ipnetwork)) {
if (!IPNetwork.TryParse(ip, out ipnetwork)) {
ipn = null;
return false;
}
}
}
ipn = ipnetwork;
return true;
}
protected override void BecauseOf()
{
m_result = new IPNetwork(Value, PrefixLength);
}
internal IPAddressCollection(IPNetwork ipnetwork)
{
this._ipnetwork = ipnetwork;
this._enumerator = -1;
}
internal static bool IsIn(this IPAddress address, IPNetwork network) => network.Contains(address);
internal IPAddressCollection(IPNetwork ipnetwork, FilterEnum filter)
{
this._ipnetwork = ipnetwork;
this._filter = filter;
Reset();
}
public override IPRanges GetIPRanges()
{
return(new IPRanges(new IPRange(IPNetwork.Parse(Subnet, Netmask))));
}
public geoIp(IPNetwork network, GeoLocateResult data)
{
Network = network;
Result = data;
}
public static IPAddress[] ConvertIPRangeToIPAddresses(string[] ipRanges, CancellationToken cancellationToken)
{
ConcurrentBag <IPAddress> bag = new ConcurrentBag <IPAddress>();
ParallelOptions parallelOptions = new ParallelOptions()
{
CancellationToken = cancellationToken
};
foreach (string ipOrRange in ipRanges)
{
// Match 192.168.0.1
if (Regex.IsMatch(ipOrRange, RegexHelper.IPv4AddressRegex))
{
bag.Add(IPAddress.Parse(ipOrRange));
continue;
}
// Match 192.168.0.0/24 or 192.168.0.0/255.255.255.0
if (Regex.IsMatch(ipOrRange, RegexHelper.IPv4AddressCidrRegex) || Regex.IsMatch(ipOrRange, RegexHelper.IPv4AddressSubnetmaskRegex))
{
IPNetwork network = IPNetwork.Parse(ipOrRange);
Parallel.For(IPv4AddressHelper.ConvertToInt32(network.Network), IPv4AddressHelper.ConvertToInt32(network.Broadcast) + 1, parallelOptions, i =>
{
bag.Add(IPv4AddressHelper.ConvertFromInt32(i));
parallelOptions.CancellationToken.ThrowIfCancellationRequested();
});
continue;
}
// Match 192.168.0.0 - 192.168.0.100
if (Regex.IsMatch(ipOrRange, RegexHelper.IPv4AddressRangeRegex))
{
string[] range = ipOrRange.Split('-');
Parallel.For(IPv4AddressHelper.ConvertToInt32(IPAddress.Parse(range[0])), IPv4AddressHelper.ConvertToInt32(IPAddress.Parse(range[1])) + 1, parallelOptions, i =>
{
bag.Add(IPv4AddressHelper.ConvertFromInt32(i));
parallelOptions.CancellationToken.ThrowIfCancellationRequested();
});
continue;
}
// Convert 192.168.[50-100,200].1 to 192.168.50.1, 192.168.51.1, 192.168.52.1, {..}, 192.168.200.1
if (Regex.IsMatch(ipOrRange, RegexHelper.IPv4AddressSpecialRangeRegex))
{
string[] octets = ipOrRange.Split('.');
List <List <int> > list = new List <List <int> >();
// Go through each octet...
for (int i = 0; i < octets.Length; i++)
{
List <int> innerList = new List <int>();
// Create a range for each octet
if (Regex.IsMatch(octets[i], RegexHelper.SpecialRangeRegex))
{
foreach (string numberOrRange in octets[i].Substring(1, octets[i].Length - 2).Split(','))
{
// 50-100
if (numberOrRange.Contains("-"))
{
string[] rangeNumbers = numberOrRange.Split('-');
for (int j = int.Parse(rangeNumbers[0]); j < (int.Parse(rangeNumbers[1]) + 1); j++)
{
innerList.Add(j);
}
} // 200
else
{
innerList.Add(int.Parse(numberOrRange));
}
}
}
else
{
innerList.Add(int.Parse(octets[i]));
}
list.Add(innerList);
}
// Build the new ipv4
foreach (int i in list[0])
{
foreach (int j in list[1])
{
foreach (int k in list[2])
{
foreach (int h in list[3])
{
bag.Add(IPAddress.Parse(string.Format("{0}.{1}.{2}.{3}", i, j, k, h)));
}
}
}
}
continue;
}
}
return(bag.ToArray());
}
private static IDictionary <IPNetwork, string> CreateSubnetDictionary(string ipFilePath)
{
var subnets = new Dictionary <IPNetwork, string>();
string ipFileList = ConfigurationManager.AppSettings["AzureIpRangeFileList"];
// Load Azure ip range data
foreach (string filePath in ipFileList.Split(';'))
{
var xmlDoc = new XmlDocument();
xmlDoc.Load(ipFilePath + @"\IpRangeFiles\Azure\" + filePath);
var root = xmlDoc.DocumentElement;
foreach (XmlElement ele in root)
{
string region = ele.GetAttribute("Name");
foreach (XmlElement ipRange in ele)
{
var subnet = ipRange.GetAttribute("Subnet");
IPNetwork net;
if (IPNetwork.TryParse(subnet, out net))
{
if (!subnets.ContainsKey(net))
{
subnets.Add(net, region);
}
}
}
}
}
// Get AWS ip range data
string awsIpFile = ConfigurationManager.AppSettings["AwsIpRangeFile"];
string json = File.ReadAllText(ipFilePath + @"\IpRangeFiles\AWS\" + awsIpFile);
var jsSerializer = new JavaScriptSerializer();
var awsIpRangeData = jsSerializer.Deserialize <AwsIpRangeData>(json);
foreach (var prefix in awsIpRangeData.prefixes)
{
IPNetwork net;
if (IPNetwork.TryParse(prefix.ip_prefix, out net))
{
if (!subnets.ContainsKey(net))
{
subnets.Add(net, prefix.region);
}
}
}
// Get AliCloud ip range data
string aliCloudIpFile = ConfigurationManager.AppSettings["AliCloudIpRangeFile"];
string[] lines = File.ReadAllLines(ipFilePath + @"\IpRangeFiles\AliCloud\" + aliCloudIpFile);
foreach (var line in lines)
{
IPNetwork net;
if (IPNetwork.TryParse(line, out net))
{
if (!subnets.ContainsKey(net))
{
subnets.Add(net, "alicloud");
}
}
}
return(subnets);
}
public static IPAddress[] CreateIPAddressesFromIPRanges(string[] ipRanges, CancellationToken cancellationToken)
{
var bag = new ConcurrentBag <IPAddress>();
var parallelOptions = new ParallelOptions
{
CancellationToken = cancellationToken
};
foreach (var ipOrRange in ipRanges)
{
// 192.168.0.1
if (Regex.IsMatch(ipOrRange, RegexHelper.IPv4AddressRegex))
{
bag.Add(IPAddress.Parse(ipOrRange));
continue;
}
// 192.168.0.0/24 or 192.168.0.0/255.255.255.0
if (Regex.IsMatch(ipOrRange, RegexHelper.IPv4AddressCidrRegex) || Regex.IsMatch(ipOrRange, RegexHelper.IPv4AddressSubnetmaskRegex))
{
var network = IPNetwork.Parse(ipOrRange);
Parallel.For(IPv4Address.ToInt32(network.Network), IPv4Address.ToInt32(network.Broadcast) + 1, parallelOptions, i =>
{
bag.Add(IPv4Address.FromInt32(i));
parallelOptions.CancellationToken.ThrowIfCancellationRequested();
});
continue;
}
// 192.168.0.0 - 192.168.0.100
if (Regex.IsMatch(ipOrRange, RegexHelper.IPv4AddressRangeRegex))
{
var range = ipOrRange.Split('-');
Parallel.For(IPv4Address.ToInt32(IPAddress.Parse(range[0])), IPv4Address.ToInt32(IPAddress.Parse(range[1])) + 1, parallelOptions, i =>
{
bag.Add(IPv4Address.FromInt32(i));
parallelOptions.CancellationToken.ThrowIfCancellationRequested();
});
continue;
}
// 192.168.[50-100,200].1 --> 192.168.50.1, 192.168.51.1, 192.168.52.1, {..}, 192.168.200.1
if (Regex.IsMatch(ipOrRange, RegexHelper.IPv4AddressSpecialRangeRegex))
{
var octets = ipOrRange.Split('.');
var list = new List <List <int> >();
// Go through each octet...
foreach (var octet in octets)
{
var innerList = new List <int>();
// Create a range for each octet
if (Regex.IsMatch(octet, RegexHelper.SpecialRangeRegex))
{
foreach (var numberOrRange in octet.Substring(1, octet.Length - 2).Split(','))
{
// 50-100
if (numberOrRange.Contains("-"))
{
var rangeNumbers = numberOrRange.Split('-');
for (var i = int.Parse(rangeNumbers[0]); i < (int.Parse(rangeNumbers[1]) + 1); i++)
{
innerList.Add(i);
}
} // 200
else
{
innerList.Add(int.Parse(numberOrRange));
}
}
}
else
{
innerList.Add(int.Parse(octet));
}
list.Add(innerList);
}
// Build the new ipv4
foreach (var i in list[0])
{
foreach (var j in list[1])
{
foreach (var k in list[2])
{
foreach (var h in list[3])
{
bag.Add(IPAddress.Parse($"{i}.{j}.{k}.{h}"));
}
}
}
}
continue;
}
// 2001:db8:85a3::8a2e:370:7334
if (Regex.IsMatch(ipOrRange, RegexHelper.IPv6AddressRegex))
{
bag.Add(IPAddress.Parse(ipOrRange));
}
}
return(bag.ToArray());
}
static void Main(string[] args)
{
var showHelp = false;
var loadTarget = 4;
var options = new OptionSet
{
"Usage: TlsConnectStressTest.exe --load 4",
{ "h|?|help", "Displays usage instructions.", val => showHelp = val != null },
{ "load=", "Amount of load to generate, from 1 to N", (int x) => loadTarget = x }
};
var remainingOptions = options.Parse(args);
if (showHelp)
{
options.WriteOptionDescriptions(Console.Out);
return;
}
if (remainingOptions.Count != 0)
{
Console.WriteLine("Unknown command line parameters: {0}", string.Join(" ", remainingOptions.ToArray()));
Console.WriteLine("For usage instructions, use the --help command line parameter.");
return;
}
var targetUrl = new Uri("https://localhost:443");
var payload = Helpers.Random.GetBytes(1 * 1024 * 1024);
var iterations = 0L;
var clientRange = IPNetwork.Parse("127.0.0.0/16");
var clientAddresses = new List <IPAddress>(256 * 256 * 256);
foreach (var address in clientRange.ListIPAddress(FilterEnum.Usable).ToList())
{
clientAddresses.Add(address);
}
var serverEndpoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 443);
var threadCount = loadTarget;
var threads = new Thread[threadCount];
for (var i = 0; i < threadCount; i++)
{
bool ValidateServerCertificate(object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors) => true;
void ThreadEntryPoint()
{
while (true)
{
try
{
// We exhaust local dynamic port pool per IP address, so just hop addresses.
var clientAddress = Helpers.Random.GetRandomItem(clientAddresses);
using var client = new TcpClient(new IPEndPoint(clientAddress, 0));
// We want to send small packets, trickled one by one.
client.NoDelay = true;
// One would hope that this prevents the client port from hanging around for long.
// One would be wrong but we might as well try.
client.LingerState.Enabled = false;
client.LingerState.LingerTime = 1;
// Just in case.
client.SendTimeout = 1000;
client.ReceiveTimeout = 1000;
client.Connect(serverEndpoint);
using var rawStream = client.GetStream();
using var slicer = new SlicerStream(rawStream);
using var stream = new SslStream(slicer, false, ValidateServerCertificate, null);
stream.AuthenticateAsClient("127.0.0.1");
stream.Write(payload);
stream.Flush();
stream.ReadByte();
rawStream.Close(100);
}
catch
{
// Don't really care about errors.
}
finally
{
Interlocked.Increment(ref iterations);
}
}
}
threads[i] = new Thread(ThreadEntryPoint)
{
IsBackground = true,
Name = $"Worker #{i}"
};
threads[i].Start();
}
Console.WriteLine($"Starting https://127.0.0.1:443 with {threadCount} threads.");
while (true)
{
Thread.Sleep(TimeSpan.FromSeconds(5));
Console.WriteLine($"Iteration {iterations:N0}");
}
}
/// <summary>
/// Gets all unique <c>pairs</c> of hosts with monitoring flag set and which share the same subnet.<br/>
/// Subnets with less than or more than two hosts will be discarded.
/// </summary>
/// <param name="hamnetDbAccess">The handle to access the database.</param>
/// <param name="subnet">The subnet to return data for.</param>
/// <returns>The dictionary mapping a subnet to its unique monitored host pair.</returns>
public static IReadOnlyDictionary <IHamnetDbSubnet, IHamnetDbHosts> UniqueMonitoredHostPairsInSubnet(this IHamnetDbAccess hamnetDbAccess, IPNetwork subnet)
{
if (hamnetDbAccess == null)
{
throw new ArgumentNullException(nameof(hamnetDbAccess), "hamnetDbAccess to work with is null");
}
if (subnet == null)
{
throw new ArgumentNullException(nameof(subnet), "subnet search monitored hosts for is null");
}
var directSupportHamnetAccess = hamnetDbAccess as IDirectSupportOfHamnetDbAccessExtensions;
if (directSupportHamnetAccess != null)
{
return(directSupportHamnetAccess.UniqueMonitoredHostPairsInSubnet(subnet));
}
var hosts = hamnetDbAccess.QueryMonitoredHosts();
var allSubnets = hamnetDbAccess.QuerySubnets();
// filter out parents for which we have nested subnets
var subnets = allSubnets.Where(s => !allSubnets.Any(a => !object.ReferenceEquals(s.Subnet, a.Subnet) && s.Subnet.Contains(a.Subnet)));
var association = subnets.AssociateHosts(hosts);
var uniquePairs = association
.Where(a => subnet.Contains(a.Key.Subnet) || subnet.Equals(a.Key.Subnet))
.Where(a => a.Value.Count == 2)
.ToDictionary(k => k.Key, v => v.Value);
return(uniquePairs);
}
public Subnet(String input)
{
Input = input;
Network = IPNetwork.Parse(input);
}
public void FindDevices()
{
DevicesLoading = true;
DevicesAlreadyAdded = 0;
DevicesNotAdded = 0;
NetworkNodesFound = 0;
nodesChecked = 0;
DeviceInfos.Clear();
addressRange = null;
LogItems.Clear();
pingTimeout = PingTimeout;
var hostIp = Network_Functions.GetHostIP();
var hostSubnet = Network_Functions.GetSubnetMask(hostIp);
if (hostIp != null && hostSubnet != null)
{
var ipNetwork = IPNetwork.Parse(hostIp, hostSubnet);
if (ipNetwork != null)
{
var ips = IPNetwork.ListIPAddress(ipNetwork).ToList();
if (ips != null && ips.Count > 0)
{
// Get Start Address
IPAddress start = null;
IPAddress.TryParse(StartAddress, out start);
// Get End Address
IPAddress end = null;
IPAddress.TryParse(EndAddress, out end);
if (start != null && end != null)
{
AddtoLog(LogType.INFO, "Starting Auto Detect..");
AddtoLog(LogType.INFO, "IP Address Range : From " + start.ToString() + " to " + end.ToString());
AddtoLog(LogType.INFO, "Port Range : From " + portRangeStart.ToString() + " to " + portRangeStop.ToString());
var range = new Network_Functions.IPAddressRange(start, end);
addressRange = ips.FindAll(o => range.IsInRange(o));
int localhostIndex = addressRange.FindIndex(o => o.ToString() == hostIp.ToString());
if (localhostIndex >= 0)
{
addressRange[localhostIndex] = IPAddress.Loopback;
}
}
}
}
}
portRangeStart = StartPort;
portRangeStop = EndPort;
SearchProgressValue = 0;
SearchProgressMaximum = 0;
stop = new ManualResetEvent(false);
ThreadPool.QueueUserWorkItem(new WaitCallback(FindDevices_Worker));
}
public IEnumerable <ValidationResult> Validate(ValidationContext validationContext)
{
var results = new List <ValidationResult>();
// Subnet name must be unique.
if (VirtualNetwork.Subnets.Where(s => s.Name.Equals(Name)).FirstOrDefault() != null)
{
results.Add(new ValidationResult("Subnet name must be unique within a virtual network."));
}
// IpPerInstance must be > 0 for non fixed cidr.
if (!Service.FixedSubnetCidr && IpPerInstance <= 0)
{
results.Add(new ValidationResult("Address/Instance must be greater than 0."));
}
// Number of instances need to be between min and max.
if (!Service.FixedSubnetCidr && Service.MaxInstances > Service.MinInstances &&
(ServiceInstances > Service.MaxInstances || ServiceInstances < Service.MinInstances))
{
results.Add(new ValidationResult($"The instance must be between {Service.MinInstances} and {Service.MaxInstances}."));
}
var ipAddress = IPAddress.Parse(StartIP);
IPNetwork network1 = IPNetwork.Parse("10.0.0.0/8");
IPNetwork network2 = IPNetwork.Parse("172.16.0.0/12");
IPNetwork network3 = IPNetwork.Parse("192.168.0.0/16");
if (!network1.Contains(ipAddress) && !network2.Contains(ipAddress) && !network3.Contains(ipAddress))
{
results.Add(new ValidationResult($"The start ip is not in the range of RFC1918."));
return(results);
}
var network = Network;
if (IPRangeId < 0)
{
results.Add(new ValidationResult($"The subnet address range {network} is not contained in the virtual network's address spaces."));
return(results);
}
// Validate CIDR block.
if (!Equals(network.Network, ipAddress))
{
var current = IPNetwork.ToBigInteger(network.Network);
var next = current + network.Total;
var nextIp = IPNetwork.ToIPAddress(next, AddressFamily.InterNetwork);
results.Add(new ValidationResult($"{StartIP}/{network.Cidr} is not a valid CIDR block. Try {network.Network} or {nextIp} instead."));
return(results);
}
// Overlap with other subnets
foreach (var subnet in VirtualNetwork.Subnets)
{
if (network.Overlap(subnet.Network))
{
results.Add(new ValidationResult($"The subnet address range {network} overlaps with {subnet.Name} address range {subnet.Network}."));
break;
}
}
return(results);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="pathBlocksIp">Ruta de bloques ip</param>
/// <param name="pathLocations">Ruta de posiciones</param>
public GeoLite2LocationProvider(string pathBlocksIp, string pathLocations)
{
if (File.Exists(pathBlocksIp) && File.Exists(pathLocations))
{
Dictionary <long, GeoLocateResult> data = new Dictionary <long, GeoLocateResult>();
using (Stream fs = CompressHelper.UnGzFile(pathLocations))
using (StreamReader sr = new StreamReader(fs))
{
Parallel.ForEach <string>(LineGenerator(sr), line =>
{
string[] sp = line.Split(',');
if (sp.Length <= 0)
{
return;
}
long c;
if (long.TryParse(sp[0], out c))
{
switch (sp.Length)
{
case 6:
{
// Archivo de paises
GeoLocateResult add = new GeoLocateResult(sp[2] + "-" + sp[4], (string.IsNullOrEmpty(sp[3]) ? "" : sp[3] + " - ") + sp[5]);
lock (data) data.Add(c, add);
break;
}
case 13:
{
// Archivo de paises y poblaciones
GeoLocateResult add = new GeoLocateResult(sp[2] + "-" + sp[4], (string.IsNullOrEmpty(sp[12]) ? "" : sp[12] + " - ") + sp[5]);
lock (data) data.Add(c, add);
break;
}
}
}
}
);
}
List <geoIp> l = new List <geoIp>();
using (Stream fs = CompressHelper.UnGzFile(pathBlocksIp))
using (StreamReader sr = new StreamReader(fs))
{
Parallel.ForEach <string>(LineGenerator(sr), line =>
{
string[] sp = line.Split(',');
// El archivo grande y pequeño están organizados igual
if (sp.Length != 10 && sp.Length != 6)
{
return;
}
long c;
GeoLocateResult r;
if (long.TryParse(sp[2], out c) && data.TryGetValue(c, out r))
{
IPNetwork net;
if (IPNetwork.TryParse(sp[0], out net))
{
geoIp add = new geoIp(net, r);
lock (l) l.Add(add);
}
}
}
);
}
_Locates = l.ToArray();
}
}
private async void ProcessMessageAsync(UdpReceiveResult udpMessage)
{
await Task.Run(async() =>
{
DnsMessage message = new DnsMessage();
DnsQuestion question;
try
{
var respondedFromCache = false;
try
{
message = DnsMessage.Parse(udpMessage.Buffer);
question = message.Questions[0];
}
catch (Exception)
{
throw new ParsingException();
}
// Check for authorized subnet access
var allowedClient = _options.AllowedClientIPs;
var clientIP = udpMessage.RemoteEndPoint.Address;
if ((allowedClient != null) && (allowedClient.Count > 0))
{
if (allowedClient.All(ipNetwork => !IPNetwork.Contains(ipNetwork, clientIP)))
{
logger.Warn($"{clientIP} is not authorized.");
throw new AuthorizationException();
}
}
logger.Info($"{clientIP} requested {question.Name} (#{message.TransactionID}, {question.RecordType}).");
// Query cache
if (_options.CacheResponse)
{
if (Cache.ContainsKey(question.Name) && Cache[question.Name].ContainsKey(question.RecordType))
{
var entry = Cache[question.Name][question.RecordType];
if (!entry.IsExpired)
{
var cachedMessage = entry.Message;
logger.Info($"-> #{message.TransactionID} served from cache.");
cachedMessage.TransactionID = message.TransactionID; // Update transaction ID
cachedMessage.TSigOptions = message.TSigOptions; // Update TSig _options
message = cachedMessage;
respondedFromCache = true;
}
}
}
var targetNameServer = _options.LocalNameServer;
var useHttpQuery = _options.UseHttpQuery;
var queryTimeout = _options.QueryTimeout;
var useCompressionMutation = _options.CompressionMutation;
// Match rules
if (message.IsQuery &&
(question.RecordType == RecordType.A || question.RecordType == RecordType.Aaaa))
{
for (var i = Rules.Count - 1; i >= 0; i--)
{
var match = Regex.Match(question.Name, Rules[i].Pattern);
if (!match.Success)
{
continue;
}
// Domain name matched
var recordType = question.RecordType;
if (Rules[i].ForceAAAA != null && Rules[i].ForceAAAA.Value) // RecordType override
{
recordType = RecordType.Aaaa;
}
if (Rules[i].NameServer != null) // Name server override
{
targetNameServer = Rules[i].NameServer;
}
if (Rules[i].UseHttpQuery != null) // HTTP query override
{
useHttpQuery = Rules[i].UseHttpQuery.Value;
}
if (Rules[i].QueryTimeout != null) // Query timeout override
{
queryTimeout = Rules[i].QueryTimeout.Value;
}
if (Rules[i].CompressionMutation != null) // Compression pointer mutation override
{
useCompressionMutation = Rules[i].CompressionMutation.Value;
}
if (Rules[i].Address != null)
{
IPAddress ip;
IPAddress.TryParse(Rules[i].Address, out ip);
if (ip == null) // Invalid IP, may be a domain name
{
var address = string.Format(Rules[i].Address, match.Groups.Cast <object>().ToArray());
if (recordType == RecordType.A && useHttpQuery)
{
await ResolveWithHttp(targetNameServer, address, queryTimeout, message);
}
else
{
var serverEndpoint = Utils.CreateIpEndPoint(targetNameServer, 53);
var dnsClient = new DnsClient(serverEndpoint.Address, queryTimeout,
serverEndpoint.Port);
var response =
await
Task <DnsMessage> .Factory.FromAsync(dnsClient.BeginResolve,
dnsClient.EndResolve,
address, recordType, question.RecordClass, null);
if (response == null)
{
logger.Warn($"Remote resolve failed for {address}.");
return;
}
foreach (var answerRecord in response.AnswerRecords)
{
answerRecord.Name = question.Name;
message.AnswerRecords.Add(answerRecord);
}
message.ReturnCode = response.ReturnCode;
message.IsQuery = false;
}
}
else
{
if (recordType == RecordType.A &&
ip.AddressFamily == AddressFamily.InterNetwork)
{
message.AnswerRecords.Add(new ARecord(question.Name, 600, ip));
}
else if (recordType == RecordType.Aaaa &&
ip.AddressFamily == AddressFamily.InterNetworkV6)
{
message.AnswerRecords.Add(new AaaaRecord(question.Name, 600, ip));
}
else // Type mismatch
{
continue;
}
message.ReturnCode = ReturnCode.NoError;
message.IsQuery = false;
}
}
break;
}
}
// TODO: Consider how to integrate System.Net.Dns with this project.
// Using System.Net.Dns to forward query if compression mutation is disabled
//if (message.IsQuery && !useCompressionMutation &&
// (question.RecordType == RecordType.A || question.RecordType == RecordType.Aaaa))
//{
// var dnsResponse = await Dns.GetHostAddressesAsync(question.Name);
// if (question.RecordType == RecordType.A)
// {
// message.AnswerRecords.AddRange(dnsResponse.Where(
// ip => ip.AddressFamily == AddressFamily.InterNetwork).Select(
// ip => new ARecord(question.Name, 0, ip)));
// else if (question.RecordType == RecordType.Aaaa)
// {
// message.AnswerRecords.AddRange(dnsResponse.Where(
// ip => ip.AddressFamily == AddressFamily.InterNetworkV6).Select(
// ip => new AaaaRecord(question.Name, 0, ip)));
// }
// message.ReturnCode = ReturnCode.NoError;
// message.IsQuery = false;
//}
if (message.IsQuery && question.RecordType == RecordType.A && useHttpQuery)
{
await ResolveWithHttp(targetNameServer, question.Name, queryTimeout, message);
}
if (message.IsQuery)
{
// Use internal forwarder to forward query to another name server
await ForwardMessage(message, udpMessage, Utils.CreateIpEndPoint(targetNameServer, 53),
queryTimeout, useCompressionMutation);
}
else
{
// Already answered, directly return to the client
byte[] responseBuffer;
message.Encode(false, out responseBuffer);
if (responseBuffer != null)
{
await
_udpListener.SendAsync(responseBuffer, responseBuffer.Length, udpMessage.RemoteEndPoint);
// Update cache
if (_options.CacheResponse && !respondedFromCache)
{
Cache.Update(question, message, _options.CacheAge);
}
}
}
}
catch (ParsingException)
{
}
catch (AuthorizationException)
{
message.ReturnCode = ReturnCode.Refused;
message.IsQuery = false;
// Already answered, directly return to the client
byte[] responseBuffer;
message.Encode(false, out responseBuffer);
if (responseBuffer != null)
{
await
_udpListener.SendAsync(responseBuffer, responseBuffer.Length, udpMessage.RemoteEndPoint);
}
}
catch (SocketException e)
{
logger.Error("[Listener.Send] Unexpected socket error:\n{0}", e);
}
catch (Exception e)
{
logger.Error("[Processor] Unexpected exception:\n{0}", e);
}
});
}
public void AddPacketHandler(IPNetwork network, String sharedSecret, IPacketHandler packetHandler)
{
_packetHandlerRepository.Add(network, packetHandler, sharedSecret);
}
/// <summary>
/// 设置绕行规则
/// </summary>
/// <returns>是否设置成功</returns>
private bool SetupRouteTable()
{
Logging.Info("收集路由表规则");
Global.MainForm.StatusText(i18N.Translate("SetupBypass"));
Logging.Info("绕行 → 全局绕过 IP");
_directIPs.AddRange(Global.Settings.BypassIPs.Select(IPNetwork.Parse));
Logging.Info("绕行 → 服务器 IP");
_directIPs.AddRange(_serverAddresses.Where(address => !IPAddress.IsLoopback(address)).Select(address => IPNetwork.Parse(address.ToString(), 32)));
if (_savedMode.BypassChina)
{
Logging.Info("绕行 → 中国 IP");
_directIPs.AddRange(Encoding.UTF8.GetString(Resources.CNIP).Split('\n').Select(IPNetwork.Parse));
}
Logging.Info("绕行 → 局域网 IP");
_directIPs.AddRange(_bypassLanIPs.Select(IPNetwork.Parse));
switch (_savedMode.Type)
{
case 1:
// 代理规则
Logging.Info("代理 → 规则 IP");
_proxyIPs.AddRange(_savedMode.Rule.Select(IPNetwork.Parse));
//处理 NAT 类型检测，由于协议的原因，无法仅通过域名确定需要代理的 IP，自己记录解析了返回的 IP，仅支持默认检测服务器
if (Global.Settings.STUN_Server == "stun.stunprotocol.org")
{
try
{
Logging.Info("代理 → STUN 服务器 IP");
_proxyIPs.AddRange(new[]
{
Dns.GetHostAddresses(Global.Settings.STUN_Server)[0],
Dns.GetHostAddresses("stunresponse.coldthunder11.com")[0]
}.Select(ip => IPNetwork.Parse(ip.ToString(), 32)));
}
catch
{
Logging.Info("NAT 类型测试域名解析失败，将不会被添加到代理列表");
}
}
if (Global.Settings.TUNTAP.ProxyDNS)
{
Logging.Info("代理 → 自定义 DNS");
if (Global.Settings.TUNTAP.UseCustomDNS)
{
var dns = string.Empty;
foreach (var value in Global.Settings.TUNTAP.DNS)
{
dns += value;
dns += ',';
}
dns = dns.Trim();
dns = dns.Substring(0, dns.Length - 1);
RouteAction(Action.Create, dns, 32, RouteType.TUNTAP);
}
else
{
_proxyIPs.AddRange(new[] { "1.1.1.1", "8.8.8.8", "9.9.9.9", "185.222.222.222" }.Select(ip => IPNetwork.Parse(ip, 32)));
}
}
break;
case 2:
// 绕过规则
// 将 TUN/TAP 网卡权重放到最高
Process.Start(new ProcessStartInfo
{
FileName = "netsh",
Arguments = $"interface ip set interface {Global.TUNTAP.Index} metric=0",
WindowStyle = ProcessWindowStyle.Hidden,
UseShellExecute = true,
CreateNoWindow = true
}
);
Logging.Info("绕行 → 规则 IP");
_directIPs.AddRange(_savedMode.Rule.Select(IPNetwork.Parse));
Logging.Info("代理 → 全局");
if (!RouteAction(Action.Create, IPNetwork.Parse("0.0.0.0", 0), RouteType.TUNTAP))
{
State = State.Stopped;
return(false);
}
break;
}
Logging.Info("设置路由规则");
RouteAction(Action.Create, _directIPs, RouteType.Gateway);
RouteAction(Action.Create, _proxyIPs, RouteType.TUNTAP);
return(true);
}
public void AddIngress(IPNetwork network, Protocol protocol, Ports port)
{
AddIngress(network, protocol, port, port);
}
private static async Task ProcessFirewallLogEntry(AzureIpRange ipAddresses, LogParser _logParser, int _hitCounter, FirewallLogEntry firewallLogEntry)
{
Regex extractIpAddress = new Regex(@"\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b");
MatchCollection ipAddressFromRegex = extractIpAddress.Matches(firewallLogEntry.DestinationIP);
if (ipAddressFromRegex.Count == 0)
{
Console.WriteLine($"Error: unable to parse log entry: '{firewallLogEntry.DestinationIP}'");
return;
}
var cleanIpAddress = ipAddressFromRegex[0].Value;
var hitsPerIp = new Dictionary <string, AzureServiceTag>();
bool isAzureIp = false;
await Task.Run(() =>
{
IPAddress ipAdress;
if (IPAddress.TryParse(cleanIpAddress, out ipAdress))
{
foreach (var serviceType in ipAddresses.values)
{
foreach (var subnet in serviceType.properties.addressPrefixes)
{
var subnetInfo = IPNetwork.Parse(subnet);
if (subnetInfo.Contains(ipAdress))
{
isAzureIp = true;
hitsPerIp = _logParser.ReportMatchForAzureIp(
cleanIpAddress,
subnet,
serviceType,
firewallLogEntry,
subnetInfo,
hitsPerIp);
}
}
}
}
if (isAzureIp)
{
_logParser.ConsolidateResultsForAzureIP(hitsPerIp);
}
if (!isAzureIp)
{
_logParser.ReportNonAzureIP(
cleanIpAddress,
firewallLogEntry);
}
if (_options.Verbose && _logParser.TotalHitCount != _hitCounter)
{
throw new Exception($"Inconsistency in stats generation while processing: {JsonConvert.SerializeObject(firewallLogEntry)}");
}
}).ConfigureAwait(false);
}
public void AddIngress(IPNetwork network, Protocol protocol, Ports beginPort, Ports endPort)
{
AddIngress(network.ToString(), protocol, beginPort, endPort);
}
protected override void BecauseOf()
{
m_result = new IPNetwork(0x11223344, 32);
}
private static bool TryParseIPNetwork(string ip, CidrParseEnum cidrParseEnum, byte cidr, out IPNetwork ipn)
{
IPNetwork ipnetwork = null;
if (cidrParseEnum == CidrParseEnum.Default)
{
if (!IPNetwork.TryParse(ip, out ipnetwork))
{
ipn = null;
return(false);
}
}
else if (cidrParseEnum == CidrParseEnum.Value)
{
if (!IPNetwork.TryParse(ip, cidr, out ipnetwork))
{
if (!IPNetwork.TryParse(ip, out ipnetwork))
{
ipn = null;
return(false);
}
}
}
ipn = ipnetwork;
return(true);
}
private static void PrintNetwork(ProgramContext ac, IPNetwork ipn) {
StringWriter sw = new StringWriter();
if (ac.IPNetwork) sw.WriteLine("IPNetwork : {0}", ipn.ToString());
if (ac.Network) sw.WriteLine("Network : {0}", ipn.Network.ToString());
if (ac.Netmask) sw.WriteLine("Netmask : {0}", ipn.Netmask.ToString());
if (ac.Cidr) sw.WriteLine("Cidr : {0}", ipn.Cidr);
if (ac.Broadcast) sw.WriteLine("Broadcast : {0}", ipn.Broadcast.ToString());
if (ac.FirstUsable) sw.WriteLine("FirstUsable : {0}", ipn.FirstUsable.ToString());
if (ac.LastUsable) sw.WriteLine("LastUsable : {0}", ipn.LastUsable.ToString());
if (ac.Usable) sw.WriteLine("Usable : {0}", ipn.Usable);
if (ac.Total) sw.WriteLine("Total : {0}", ipn.Total);
Console.Write(sw.ToString());
}
public void ConfigureServices(IServiceCollection services)
{
var redisConnectionString = configuration.GetValue <string>("REDIS_CONNECTIONSTRING", null);
var dataProtectionPath = configuration.GetValue <string>("KEY_RING_PATH", null);
if (!string.IsNullOrEmpty(redisConnectionString))
{
services.AddStackExchangeRedisCache(options =>
{
options.Configuration = redisConnectionString;
options.InstanceName = Assembly.GetExecutingAssembly().GetName().Name;
});
services.AddDataProtection()
.SetApplicationName(Assembly.GetExecutingAssembly().GetName().Name)
.PersistKeysToStackExchangeRedis(ConnectionMultiplexer.Connect(redisConnectionString), "data-protection-keys");
}
else
{
services.AddDistributedMemoryCache();
var dpBuilder = services.AddDataProtection()
.SetApplicationName(Assembly.GetExecutingAssembly().GetName().Name);
if (!string.IsNullOrEmpty(dataProtectionPath))
{
dpBuilder.PersistKeysToFileSystem(new DirectoryInfo(dataProtectionPath));
}
}
//Add configuration options
services.Configure <JwtTokenOptions>(opts => configuration.Bind("auth:jwt", opts));
services.Configure <JsonOptions>(opts =>
{
opts.JsonSerializerOptions.Converters.Add(new JsonStringEnumConverter());
});
services.Configure <ForwardedHeadersOptions>(options =>
{
options.ForwardLimit = 2;
var configvalue = configuration.GetValue("app:knownNetwork", string.Empty)?.Split('/');
if (configvalue.Length == 2)
{
var knownNetwork = new IPNetwork(IPAddress.Parse(configvalue[0]), int.Parse(configvalue[1]));
options.KnownNetworks.Add(knownNetwork);
}
});
//Add services
AddOpenApi(services);
services.AddCors(opts => opts.AddDefaultPolicy(policy =>
{
// try to get array of origins from section array
var corsOrigins = configuration.GetSection("app:cors:origins").GetChildren().Select(c => c.Value).ToArray();
// try to get array of origins from value
if (!corsOrigins.Any())
{
corsOrigins = configuration.GetValue("app:cors:origins", string.Empty).Split(',');
}
corsOrigins = corsOrigins.Where(o => !string.IsNullOrWhiteSpace(o)).ToArray();
if (corsOrigins.Any())
{
policy.SetIsOriginAllowedToAllowWildcardSubdomains().WithOrigins(corsOrigins);
}
}));
services.AddHealthChecks()
.AddCheck("Registrants API ready hc", () => HealthCheckResult.Healthy("API ready"), new[] { HealthCheckReadyTag })
.AddCheck("Registrants API live hc", () => HealthCheckResult.Healthy("API alive"), new[] { HealthCheckAliveTag });
services.AddControllers(options =>
{
options.Filters.Add(new HttpResponseExceptionFilter());
}).AddNewtonsoftJson(opts => opts.SerializerSettings.Converters.Add(new StringEnumConverter()));
services.AddResponseCompression();
services.AddPortalAuthentication(configuration);
services.AddAutoMapper((sp, cfg) => { cfg.ConstructServicesUsing(t => sp.GetRequiredService(t)); }, typeof(Startup));
services.AddSecurityModule();
services.Configure <MessagingOptions>(configuration.GetSection("backend"));
services.AddMessaging();
services.AddTransient <IEvacuationSearchService, EvacuationSearchService>();
}
protected override void BecauseOf()
{
m_result = new IPNetwork(0x11223344, 32);
}
public static NetInterface[] Get()
{
if (!Directory.Exists(netFolder))
{
return(new NetInterface[0]);
}
var result = Directory.EnumerateDirectories(netFolder, "*", SearchOption.TopDirectoryOnly)
.Select(_ => Path.GetFileName(_))
.ToArray();
if (result.Length <= 0)
{
return(new NetInterface[0]);
}
string[] bondNames = new string[0];
if (File.Exists(bondingMastersFile))
{
bondNames = File.ReadAllText(CommonString.Append(netFolder, "/", bondingMastersFile)).Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
}
var interfaces = new NetInterface[result.Length];
for (var i = 0; i < result.Length; i++)
{
var interfaceName = result[i];
var interfaceFolder = GetSysClassNetpath(interfaceName);
var interfaceDataFolders = Directory.EnumerateDirectories(interfaceFolder, "*", SearchOption.TopDirectoryOnly).Select(_ => Path.GetFileName(_)).ToArray();
var interfaceDataFiles = Directory.EnumerateFiles(interfaceFolder, "*", SearchOption.TopDirectoryOnly).Select(_ => Path.GetFileNameWithoutExtension(_)).ToArray();
interfaces[i] = new NetInterface();
if (File.Exists(operstateFile))
{
var operstate = File.ReadAllText(operstateFile);
interfaces[i].Active = operstate == "up" ? true : false;
}
interfaces[i].Id = interfaceName;
models.NetworkAdapterType type;
bool isInterfaceAggregator;
string[] lowerInterfaces;
if (bondNames.Contains(interfaceName))
{
type = models.NetworkAdapterType.Bond;
isInterfaceAggregator = true;
lowerInterfaces = GetLowerInterfaces(interfaceDataFiles);
}
else if (interfaceDataFolders.Contains(bridgeFolder))
{
type = models.NetworkAdapterType.Bridge;
isInterfaceAggregator = true;
lowerInterfaces = GetLowerInterfaces(interfaceDataFiles);
}
else if (interfaceDataFolders.Contains(deviceLink) || interfaceDataFiles.Contains(deviceLink))
{
type = models.NetworkAdapterType.Physical;
isInterfaceAggregator = false;
lowerInterfaces = new string[0];
}
else
{
type = models.NetworkAdapterType.Virtual;
isInterfaceAggregator = false;
lowerInterfaces = new string[0];
}
interfaces[i].Type = type;
interfaces[i].InterfaceAggregator = isInterfaceAggregator;
interfaces[i].LowerInterfaces = lowerInterfaces;
var interfaceIpAddr = CommonProcess.Execute(ipFileLocation, CommonString.Append("addr show ", interfaceName)).ToArray();
interfaces[i].HardwareConfiguration = new NetworkAdapterInfo.HardwareConfiguration()
{
MacAddress = Ip.GetNetworkAdapterMacAddresss(interfaceName),
Mtu = Ip.GetNetworkAdapterMTU(interfaceName),
Txqueuelen = Ip.GetNetworkAdapterTxqueuelen(interfaceName),
Promisc = interfaceIpAddr[0].Contains(promistStatus) ? true : false
};
var addrData = interfaceIpAddr.Where(_ => _.Contains(inet) && !_.Contains(inet6)).ToArray();
if (!addrData.Any())
{
continue;
}
var primaryAddressData = GetIpAddressAndNetworkRange(addrData[0]);
interfaces[i].PrimaryAddressConfiguration = new NetworkAdapterInfo.AddressConfiguration()
{
IpAddr = primaryAddressData.Item1,
NetworkRange = primaryAddressData.Item2
};
IPNetwork ipnetwork = IPNetwork.Parse(GetNetworkRange(addrData[0]));
interfaces[i].NetworkClass = ipnetwork.Network.ToString();
var secondaryAddressConfiguration = new NetworkAdapterInfo.AddressConfiguration[addrData.Length - 1];
for (var s = 1; s < addrData.Length; s++)
{
var currentData = GetIpAddressAndNetworkRange(addrData[s]);
secondaryAddressConfiguration[s - 1] = new NetworkAdapterInfo.AddressConfiguration()
{
IpAddr = currentData.Item1,
NetworkRange = currentData.Item2
};
}
}
return(interfaces);
}
protected override void BecauseOf()
{
m_result = new IPNetwork(new IPAddress(0x11223300), 24);
}
public void Test_ipv6_DefaultNetmask()
{
var ipnetwork = IPNetwork.Parse("::1");
Assert.AreEqual(64, ipnetwork.Cidr, "Cidr");
}
