public void OnNext(RawWhoisSection section)
{
if (section.Records != null)
{
StringBuilder rawNetwork;
this.outFile.Write(section);
this.outFile.WriteLine();
this.outFile.Flush();
if (section.Records.TryGetValue("IP-Network", out rawNetwork))
{
IPAddressRange parsedRange;
if (IPAddressRange.TryParse(rawNetwork.ToString(), out parsedRange))
{
logger.Debug(string.Format(CultureInfo.InvariantCulture, "Received records for: {0}", parsedRange));
}
else
{
logger.Debug(string.Format(CultureInfo.InvariantCulture, "Received records for: {0} (error parsing range!)", rawNetwork));
}
}
else
{
logger.Debug(string.Format(CultureInfo.InvariantCulture, "Received non IP range section type: {0}", section.Type));
}
}
else
{
logger.Error("Received an item without records");
}
}
public IEnumerable <IPAddressRange> EnumerateIPAddresses(string ruleNamePrefix = null)
{
string prefix = RulePrefix + (ruleNamePrefix ?? string.Empty);
foreach (INetFwRule rule in EnumerateRulesMatchingPrefix(prefix))
{
int commaPos = 0;
string ipList = rule.RemoteAddresses;
if (!string.IsNullOrWhiteSpace(ipList) && ipList != "*")
{
for (int i = 0; i < ipList.Length;)
{
commaPos = ipList.IndexOf(',', commaPos);
if (commaPos >= 0)
{
if (IPAddressRange.TryParse(ipList.Substring(i, commaPos - i), out IPAddressRange range))
{
yield return(range);
}
i = ++commaPos;
}
else
{
if (IPAddressRange.TryParse(ipList.Substring(i), out IPAddressRange range))
{
yield return(range);
}
break;
}
}
}
}
}
/// <summary>
/// Add cloudflare forward header options
/// </summary>
/// <param name="builder">Application builder</param>
public static void UseCloudflareForwardHeaderOptions(this IApplicationBuilder builder)
{
ForwardedHeadersOptions options = new()
{
ForwardedForHeaderName = CloudflareConnectingIpHeaderName,
ForwardedHeaders = ForwardedHeaders.All
};
try
{
var urls = builder.ServerFeatures.Get <IServerAddressesFeature>()?.Addresses;
if (urls != null && urls.Count != 0)
{
foreach (var line in GetCloudflareIp())
{
if (IPAddressRange.TryParse(line, out var range))
{
options.KnownNetworks.Add(new IPNetwork(range.Begin, range.GetPrefixLength()));
}
}
}
}
catch
{
//oh no something went wrong
}
builder.UseForwardedHeaders(options);
}
}
public void TryParse_CIDR_OutOfRange()
{
var ipadr = default(IPAddressRange);
IPAddressRange.TryParse("192.168.0.10/48", out ipadr).Is(false);
ipadr.IsNull();
}
private bool IpIsAllowed(IPAddress ip)
{
if (!_parsedProxyIpsInitialized)
{
var safeProxyIps = _settings.Web?.SafeProxyIps?.Split(",", StringSplitOptions.TrimEntries) ??
Array.Empty <string>();
foreach (var proxyIp in safeProxyIps)
{
if (proxyIp.Contains("/"))
{
// Input is probably a CIDR, so parse it to a range.
if (IPAddressRange.TryParse(proxyIp, out var range))
{
_parsedProxyIps.AddRange(range);
}
}
else if (IPAddress.TryParse(proxyIp, out var parsedIp))
{
_parsedProxyIps.Add(parsedIp);
}
else
{
_logger.LogWarning($"Could not parse IP '{proxyIp}'.");
}
}
_parsedProxyIpsInitialized = true;
}
return(IPAddress.IsLoopback(ip) || ip.Equals(NginxProxyIp) || _parsedProxyIps.Contains(ip));
}
public IEnumerable <IPAddressRange> EnumerateIPAddresses(string ruleNamePrefix = null)
{
string prefix = RulePrefix + (ruleNamePrefix ?? string.Empty);
string[] pieces;
foreach (string setFile in Directory.GetFiles(AppDomain.CurrentDomain.BaseDirectory, "*.set"))
{
if (Path.GetFileName(setFile).StartsWith(prefix))
{
foreach (string line in File.ReadLines(setFile).Skip(1).Where(l => l.StartsWith("add ")))
{
// example line: add setname ipaddress -exist
pieces = line.Split(' ');
if (IPAddressRange.TryParse(pieces[2], out IPAddressRange range))
{
yield return(range);
}
}
}
}
foreach (IPAddressRange range in firewall6.EnumerateIPAddresses(ruleNamePrefix))
{
yield return(range);
}
}
public string ToDebugString()
{
var ret = new StringBuilder();
if (this.Records != null && this.Records.Count > 0)
{
foreach (var entry in this.Records)
{
if (entry.Key == "IP-Network" && entry.Value != null)
{
IPAddressRange range;
if (IPAddressRange.TryParse(entry.Value.ToString(), out range))
{
ret.AppendFormat("{0}: {1} ({2} - {3})\r\n", entry.Key, entry.Value.ToString(), range.Begin, range.End);
}
else
{
ret.AppendFormat("{0}: {1} (could not parse range!)\r\n", entry.Key, entry.Value.ToString());
}
}
else
{
ret.AppendFormat("{0}: {1}\r\n", entry.Key, entry.Value.ToString());
}
}
}
return(ret.ToString());
}
public void TryParse_IPV4_Cipdr_Max()
{
IPAddressRange temp;
var result = IPAddressRange.TryParse("219.165.64.73/32", out temp);
result.Is(true);
temp.IsNotNull();
}
public void TryParse_Empty_String()
{
IPAddressRange temp;
var result = IPAddressRange.TryParse("", out temp);
result.Is(false);
temp.IsNull();
}
public void TryParse_InValid_String()
{
IPAddressRange temp;
var result = IPAddressRange.TryParse("fdfv", out temp);
result.Is(false);
temp.IsNull();
}
public void TryParse_IPV6()
{
IPAddressRange temp;
var result = IPAddressRange.TryParse("fe80::d503:4ee:3882:c586", out temp);
result.Is(true);
temp.IsNotNull();
}
public void TryParse_IPV4()
{
IPAddressRange temp;
var result = IPAddressRange.TryParse("192.168.60.13", out temp);
result.Is(true);
temp.IsNotNull();
}
public void TryParse_IPV4_Cipdr_BitMask()
{
IPAddressRange temp;
var result = IPAddressRange.TryParse("192.168.1.0/255.255.255.0", out temp);
result.Is(true);
temp.IsNotNull();
}
private async void BtnStart_Click(object sender, EventArgs e)
{
try
{
logger.Info("Scan starting");
var beginIpAddress = TxtIPRangeBegin.Text.Replace(",", ".").Replace(" ", "");
var endIpAddress = TxtIPRangeEnd.Text.Replace(",", ".").Replace(" ", "");
if (!IPAddressRange.TryParse(string.Format("{0}-{1}", beginIpAddress, endIpAddress), out IPAddressRange ipAddressRange))
{
MessageBox.Show("IP Range not valid!", "Input Validation Error", MessageBoxButtons.OK, MessageBoxIcon.Warning, MessageBoxDefaultButton.Button1, MessageBoxOptions.DefaultDesktopOnly);
logger.Info("IP Range validation failed. Scan aborted");
return;
}
BtnStart.Enabled = false;
logger.Info("Scan initializing");
LblStatusText.Text = "Scan Initializing";
ScanResultItems = new List <ScanResultItem>();
DgwScanResults.DataSource = typeof(ScanResultItem);
DgwScanResults.DataSource = ScanResultItems;
Scanner = new Scanner(TbParallelTaskCount.Value);
Scanner.OnStarted += Scanner_OnStarted;
Scanner.OnCanceling += Scanner_OnCanceling;
Scanner.OnCanceled += Scanner_OnCanceled;
Scanner.OnFinished += Scanner_OnFinished;
Scanner.OnPortCheckCompleted += Scanner_OnPortCheckCompleted;
logger.Info("Scan queue populating");
await Scanner.AddQueueAsync(ipAddressRange.AsEnumerable());
logger.Info("Scan start requesting");
await Scanner.StartAsync();
}
catch (AggregateException)
{
BtnStart.Enabled = true;
BtnStop.Enabled = false;
}
catch (OperationCanceledException)
{
BtnStart.Enabled = true;
BtnStop.Enabled = false;
}
catch (Exception ex)
{
logger.Error(ex);
}
}
private IPAddressRange GetIpAddressRange(string ipAddress)
{
if (ipAddress.Equals(IPAddress.IPv6Loopback.ToString()))
{
return(new IPAddressRange(IPAddress.Loopback));
}
return(IPAddressRange.TryParse(ipAddress, out IPAddressRange range)
? range
: null);
}
public override Task <bool> AllowIPAddresses(string ruleNamePrefix, IEnumerable <IPAddressRange> ipAddresses, IEnumerable <PortRange> allowedPorts = null, CancellationToken cancelToken = default)
{
IEnumerable <IPAddressRange> ipv4 = ipAddresses.Where(i => IPAddressRange.TryParse(i, out IPAddressRange obj) && obj.Begin.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork);
IEnumerable <IPAddressRange> ipv6 = ipAddresses.Where(i => IPAddressRange.TryParse(i, out IPAddressRange obj) && obj.Begin.AddressFamily == System.Net.Sockets.AddressFamily.InterNetworkV6);
bool result = base.AllowIPAddresses(ruleNamePrefix, ipv4, allowedPorts, cancelToken).Sync();
if (result)
{
result = firewall6.AllowIPAddresses(ruleNamePrefix, ipv6, allowedPorts, cancelToken).Sync();
}
return(Task.FromResult(result));
}
private void PopulateList(HashSet <string> set, List <IPAddressRange> ranges, ref Regex regex, string setValue, string regexValue)
{
setValue = (setValue ?? string.Empty).Trim();
regexValue = (regexValue ?? string.Empty).Replace("*", @"[0-9A-Fa-f:]+?").Trim();
set.Clear();
regex = null;
if (!string.IsNullOrWhiteSpace(setValue))
{
foreach (string v in setValue.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries))
{
string ipOrDns = v.Trim();
if (ipOrDns != "0.0.0.0" && ipOrDns != "::0" && ipOrDns != "127.0.0.1" && ipOrDns != "::1")
{
try
{
if (IPAddressRange.TryParse(ipOrDns, out IPAddressRange range))
{
if (range.Begin.Equals(range.End))
{
set.Add(ipOrDns);
}
else if (!ranges.Contains(range))
{
ranges.Add(range);
}
}
else if (dns != null)
{
IPAddress[] addresses = dns.GetHostEntryAsync(ipOrDns).Sync().AddressList;
if (addresses != null)
{
foreach (IPAddress adr in addresses)
{
set.Add(adr.ToString());
}
}
}
}
catch (System.Net.Sockets.SocketException)
{
// ignore, dns lookup fails
}
}
}
}
if (!string.IsNullOrWhiteSpace(regexValue))
{
regex = ParseRegex(regexValue);
}
}
public void TryParse_Fail()
{
//arrange
string addresses = "127.168.0.1-127.168.3.5.46";
IPAddressRange actualRange;
//action
bool actula = IPAddressRange.TryParse(addresses, out actualRange);
//assert
Assert.IsFalse(actula);
Assert.IsNull(actualRange);
}
public void TryParse_Success()
{
//arrange
string addresses = "127.168.0.1-127.168.3.5";
IPAddressRange actualRange;
//action
bool actula = IPAddressRange.TryParse(addresses, out actualRange);
//assert
Assert.IsTrue(actula);
Assert.IsNotNull(actualRange);
}
public void TryParse(string input, bool expectedReturn)
{
Console.WriteLine("TestCase: \"{0}\", Expected: {1}", input, expectedReturn);
var result = IPAddressRange.TryParse(input, out IPAddressRange temp);
result.Is(expectedReturn);
if (expectedReturn)
{
temp.IsNot(null);
}
else
{
temp.Is(null);
}
}
/// <summary>
/// Get a firewall ip address, clean and normalize
/// </summary>
/// <param name="ipAddress">IP Address</param>
/// <param name="normalizedIP">The normalized ip ready to go in the firewall or null if invalid ip address</param>
/// <returns>True if ip address can go in the firewall, false otherwise</returns>
public static bool TryGetFirewallIPAddress(this string ipAddress, out string normalizedIP)
{
normalizedIP = ipAddress?.Trim();
if (string.IsNullOrWhiteSpace(normalizedIP) ||
normalizedIP == "0.0.0.0" ||
normalizedIP == "127.0.0.1" ||
normalizedIP == "::0" ||
normalizedIP == "::1" ||
!IPAddressRange.TryParse(normalizedIP, out _))
{
normalizedIP = null;
return(false);
}
return(true);
}
public void TryParse_IPV4_Cipdr_Begin_To_End()
{
IPAddressRange temp;
var result = IPAddressRange.TryParse("192.168.60.26-192.168.60.37", out temp);
result.Is(true);
temp.IsNotNull();
IPAddressRange temp2;
var result2 = IPAddressRange.TryParse("192.168.60.26–192.168.60.37", out temp2);
result2.Is(true);
temp2.IsNotNull();
temp2.Begin.ToString().Is("192.168.60.26");
temp2.End.ToString().Is("192.168.60.37");
}
private IPAddressRange ExtractRangeFromRecord(RawWhoisSection section, string fieldName)
{
StringBuilder rawSectionRange;
if (section.Records != null && section.Records.TryGetValue(fieldName, out rawSectionRange))
{
IPAddressRange sectionIPRange;
if (IPAddressRange.TryParse(rawSectionRange.ToString(), out sectionIPRange))
{
return(sectionIPRange);
}
}
return(null);
}
/// <summary>
/// Helper method to check, if address is explicitly white listed or
/// not implicitly black listed.
/// </summary>
/// <param name="remoteAddress">The remote address.</param>
/// <returns></returns>
protected virtual bool IsAcceptableAddress(string remoteAddress)
{
IPAddressRange address;
if (!IPAddressRange.TryParse(remoteAddress, out address))
{
return(false);
}
var isAcceptable = WhiteListed?.Contains(address);
if (!(isAcceptable ?? false))
{
isAcceptable = !BlackListed?.Contains(address);
}
return(isAcceptable ?? true);
}
public void TryParse()
{
TestContext.Run((string input, bool expectedReturn) =>
{
Console.WriteLine("TestCase: \"{0}\", Expected: {1}", input, expectedReturn);
IPAddressRange temp;
var result = IPAddressRange.TryParse(input, out temp);
result.Is(expectedReturn);
if (expectedReturn)
{
temp.IsNotNull();
}
else
{
temp.IsNull();
}
});
}
public IEnumerable <IPAddressRange> EnumerateIPAddresses(string ruleNamePrefix = null)
{
string prefix = (string.IsNullOrWhiteSpace(ruleNamePrefix) ? RulePrefix : RulePrefix + ruleNamePrefix);
foreach (INetFwRule rule in EnumerateRulesMatchingPrefix(prefix))
{
string ipList = rule.RemoteAddresses;
if (!string.IsNullOrWhiteSpace(ipList) && ipList != "*")
{
string[] ips = ipList.Split(',');
foreach (string ip in ips)
{
if (IPAddressRange.TryParse(ip, out IPAddressRange range))
{
yield return(range);
}
// else // should never happen
}
}
}
}
/// <summary>
/// States whether a specific ip address is valid within the rules of client access control
/// </summary>
/// <param name="rule"></param>
/// <param name="ipAddress"></param>
/// <returns></returns>
public bool IsValid(IpAccessControl rule, string ipAddress)
{
IPAddressRange clientRange;
if (ipAddress.Equals(IPAddress.IPv6Loopback.ToString()))
{
clientRange = new IPAddressRange(IPAddress.Loopback);
}
else if (!IPAddressRange.TryParse(ipAddress, out clientRange))
{
return(false);
}
var ip6 = clientRange.Begin.MapToIPv6();
if (rule.Exceptions.Where(x => x.Range != null).Any(exception => exception.Range.Contains(ip6)))
{
return(rule.AccessType != IpAccessControl.AccessTypes.AllowAll);
}
return(rule.AccessType == IpAccessControl.AccessTypes.AllowAll);
}
/// <summary>
/// Return a list of ranges that contain invalid ranges
/// </summary>
/// <returns>List of errored ranges</returns>
public IEnumerable <string> InitIpAccessControl(IpAccessControl rule)
{
var errors = new List <string>();
foreach (var exception in rule.Exceptions)
{
var ipAddressRange = exception.IpAddressType == IpAccessControl.IpAddressType.Single
? exception.FromIpAddress
: $"{exception.FromIpAddress}-{exception.ToIpAddress}";
if (!IPAddressRange.TryParse(ipAddressRange, out var range))
{
errors.Add(ipAddressRange);
}
range.Begin = range.Begin.MapToIPv6();
range.End = range.End.MapToIPv6();
exception.Range = range;
}
return(errors);
}
public static NormalizedNetwork TryParseFromSection(RawWhoisSection section)
{
if (networkTypes.Contains(section.Type))
{
var network = new NormalizedNetwork()
{
Location = NormalizedLocation.TryParseFromSection(section),
AuthArea = NormalizationUtils.FindFirstMatchingFieldValueInRecords(section, authAreaFields),
OriginAS = NormalizationUtils.FindFirstMatchingFieldValueInRecords(section, originASFields),
Status = NormalizationUtils.FindFirstMatchingFieldValueInRecords(section, statusFields)
};
var candidateRanges = NormalizationUtils.FindAllMatchingFieldValuesInRecords(section, ipRangeFields);
if (candidateRanges != null)
{
IPAddressRange range = null;
foreach (var candidateRange in candidateRanges)
{
if (IPAddressRange.TryParse(candidateRange, out range))
{
break;
}
}
network.IPRange = range;
}
else
{
// TODO: Some networks do not have an explicit IP range but maybe we can get it from the Auth Area or from the ID?
}
NormalizationUtils.ExtractCommonRecordMetadata(section, section.Id, nameFields, network);
return(network);
}
return(null);
}
private bool Bypassed()
{
var ip = GetIPAddress();
if (ip == null)
{
return(false);
}
string ipRangeBypassSetting = ConfigurationManager.AppSettings["BasicAuthentication.IpRangeBypassList"];
if (string.IsNullOrEmpty(ipRangeBypassSetting))
{
return(false);
}
IEnumerable <IPAddressRange> ipRanges = ipRangeBypassSetting.Split('|', ';')
.Select(n => IPAddressRange.TryParse(n, out var ipRange) ? ipRange : null)
.Where(n => n != null);
return(ipRanges.Any(n => n.Contains(ip)));
}