/// <summary>
/// Simple check if the network interface contains any of resolver addresses.
/// </summary>
/// <param name="localNetworkInterface">The interface to check.</param>
/// <param name="optionalAddress"></param>
/// <returns><c>true</c> if a address was found, otherwise <c>false</c></returns>
internal static bool IsUsingDnsCrypt(LocalNetworkInterface localNetworkInterface, string optionalAddress = "")
{
var dns = new List <string> {
Global.PrimaryResolverAddress, Global.SecondaryResolverAddress
};
var dns6 = new List <string> {
Global.PrimaryResolverAddress6, Global.SecondaryResolverAddress6
};
if (localNetworkInterface.Ipv4Dns.Contains(dns[0]) || localNetworkInterface.Ipv4Dns.Contains(dns[1]))
{
return(true);
}
if (!string.IsNullOrEmpty(optionalAddress))
{
if (localNetworkInterface.Ipv4Dns.Contains(optionalAddress))
{
return(true);
}
}
if (localNetworkInterface.Ipv6Dns.Contains(dns6[0]) || localNetworkInterface.Ipv6Dns.Contains(dns6[1]))
{
return(true);
}
return(false);
}
/// <summary>
/// Click event for the network cards.
/// </summary>
/// <param name="localNetworkInterface">The clicked network card.</param>
public void NetworkCardClicked(LocalNetworkInterface localNetworkInterface)
{
if (localNetworkInterface == null)
{
return;
}
if (localNetworkInterface.UseDnsCrypt)
{
var status = LocalNetworkInterfaceManager.SetNameservers(localNetworkInterface, new List <string>(),
NetworkInterfaceComponent.IPv4);
LocalNetworkInterfaceManager.SetNameservers(localNetworkInterface, new List <string>(),
NetworkInterfaceComponent.IPv6);
localNetworkInterface.UseDnsCrypt = !status;
}
else
{
var dns4 = new List <string>();
var dns6 = new List <string>();
if (PrimaryResolver != null)
{
if (!string.IsNullOrEmpty(PrimaryResolver.ProviderPublicKey))
{
// only add the local address if the proxy is running
if (PrimaryDnsCryptProxyManager.DnsCryptProxy.IsReady && PrimaryDnsCryptProxyManager.IsDnsCryptProxyRunning())
{
dns4.Add(Global.PrimaryResolverAddress);
if (_userData.UseIpv6)
{
dns6.Add(Global.PrimaryResolverAddress6);
}
}
}
}
if (SecondaryResolver != null)
{
if (!string.IsNullOrEmpty(SecondaryResolver.ProviderPublicKey))
{
// only add the local address if the proxy is running
if (SecondaryDnsCryptProxyManager.DnsCryptProxy.IsReady && SecondaryDnsCryptProxyManager.IsDnsCryptProxyRunning())
{
dns4.Add(Global.SecondaryResolverAddress);
if (_userData.UseIpv6)
{
dns6.Add(Global.SecondaryResolverAddress6);
}
}
}
}
var status = LocalNetworkInterfaceManager.SetNameservers(localNetworkInterface, dns4, NetworkInterfaceComponent.IPv4);
if (_userData.UseIpv6)
{
LocalNetworkInterfaceManager.SetNameservers(localNetworkInterface, dns6, NetworkInterfaceComponent.IPv6);
}
localNetworkInterface.UseDnsCrypt = status;
}
LoadNetworkCards();
}
internal static bool IsUsingInsecureFallbackDns(LocalNetworkInterface localNetworkInterface, UserData userData)
{
if (!(userData?.InsecureResolverPair?.Addresses?.Count > 0))
{
return(false);
}
var fallbackAddresses = userData.InsecureResolverPair.Addresses;
return(fallbackAddresses.Any(fallbackAddress => localNetworkInterface.Ipv4Dns.Contains(fallbackAddress)));
}
/// <summary>
/// Simple check if the network interface contains any of resolver addresses.
/// </summary>
/// <param name="listenAddresses"></param>
/// <param name="localNetworkInterface">The interface to check.</param>
/// <returns><c>true</c> if a address was found, otherwise <c>false</c></returns>
public static bool IsUsingDnsCrypt(List <string> listenAddresses, LocalNetworkInterface localNetworkInterface)
{
if (listenAddresses == null)
{
return(false);
}
var addressOnly = (from listenAddress in listenAddresses let lastIndex = listenAddress.LastIndexOf(":", StringComparison.Ordinal) select listenAddress.Substring(0, lastIndex).Replace("[", "").Replace("]", "")).ToList();
return(localNetworkInterface.Dns.Any(d => addressOnly.Contains(d.Address)));
}
/// <summary>
/// Get a list of the local network interfaces.
/// </summary>
/// <param name="listenAddresses"></param>
/// <param name="showHiddenCards">Show hidden cards.</param>
/// <param name="showOnlyOperationalUp">Include only connected network cards.</param>
/// <returns>A (filtered) list of the local network interfaces.</returns>
/// <exception cref="NetworkInformationException">A Windows system function call failed. </exception>
/// <exception cref="ArgumentNullException"></exception>
public static List <LocalNetworkInterface> GetLocalNetworkInterfaces(List <string> listenAddresses = null, bool showHiddenCards = false,
bool showOnlyOperationalUp = true)
{
var interfaces = new List <LocalNetworkInterface>();
try
{
foreach (var nic in NetworkInterface.GetAllNetworkInterfaces())
{
if (showOnlyOperationalUp)
{
if (nic.OperationalStatus != OperationalStatus.Up)
{
continue;
}
}
if (!showHiddenCards)
{
var add = true;
foreach (var blacklistEntry in Global.NetworkInterfaceBlacklist)
{
if (nic.Description.Contains(blacklistEntry) || nic.Name.Contains(blacklistEntry))
{
add = false;
}
}
if (!add)
{
continue;
}
}
var localNetworkInterface = new LocalNetworkInterface
{
Name = nic.Name,
Description = nic.Description,
Type = nic.NetworkInterfaceType,
Dns = GetDnsServerList(nic.Id),
Ipv4Support = nic.Supports(NetworkInterfaceComponent.IPv4),
Ipv6Support = nic.Supports(NetworkInterfaceComponent.IPv6),
OperationalStatus = nic.OperationalStatus
};
//do a strict check if the interface supports IPv6
localNetworkInterface.UseDnsCrypt = IsUsingDnsCrypt(listenAddresses, localNetworkInterface, localNetworkInterface.Ipv6Support);
interfaces.Add(localNetworkInterface);
}
}
catch (Exception exception)
{
Logger.Error(exception, "GetLocalNetworkInterfaces");
}
return(interfaces);
}
/// <summary>
/// Set's the IPv4 or IPv6 DNS Servers of an interface.
/// </summary>
/// <param name="localNetworkInterface">The interface to work with.</param>
/// <param name="dnsServers">List of dns servers to set.</param>
/// <param name="networkInterfaceComponent">IPv4 or IPv6.</param>
public static void SetNameservers(LocalNetworkInterface localNetworkInterface, List<string> dnsServers,
NetworkInterfaceComponent networkInterfaceComponent = NetworkInterfaceComponent.IPv4)
{
if (networkInterfaceComponent == NetworkInterfaceComponent.IPv4)
{
using (var networkConfigMng = new ManagementClass("Win32_NetworkAdapterConfiguration"))
{
using (var networkConfigs = networkConfigMng.GetInstances())
{
foreach (
var managementObject in
networkConfigs.Cast<ManagementObject>()
.Where(
mo =>
(bool) mo["IPEnabled"] &&
(string) mo["Description"] == localNetworkInterface.Description))
{
using (var newDns = managementObject.GetMethodParameters("SetDNSServerSearchOrder"))
{
newDns["DNSServerSearchOrder"] = dnsServers.ToArray();
managementObject.InvokeMethod("SetDNSServerSearchOrder", newDns, null);
}
}
}
}
}
else
{
//TODO: find better way to set IPv6 nameservers
using (var process = new Process())
{
var processStartInfo = new ProcessStartInfo("netsh",
"interface ipv6 delete dns \"" + localNetworkInterface.Name + "\" all")
{
WindowStyle = ProcessWindowStyle.Minimized
};
process.StartInfo = processStartInfo;
process.Start();
foreach (var address in dnsServers)
{
//netsh interface ipv6 add dns "Interface Name" 127.0.0.1 validate=no
processStartInfo = new ProcessStartInfo("netsh",
"interface ipv6 add dns \"" + localNetworkInterface.Name + "\" " + address + " validate=no")
{
WindowStyle = ProcessWindowStyle.Minimized
};
process.StartInfo = processStartInfo;
process.Start();
}
}
}
}
/// <summary>
/// Get a list of the local network interfaces.
/// </summary>
/// <param name="userData"></param>
/// <param name="showHiddenCards">Show hidden cards.</param>
/// <param name="showOnlyOperationalUp">Include only connected network cards.</param>
/// <param name="optionalAddress"></param>
/// <returns>A (filtered) list of the local network interfaces.</returns>
/// <exception cref="NetworkInformationException">A Windows system function call failed. </exception>
/// <exception cref="ArgumentNullException"></exception>
internal static List <LocalNetworkInterface> GetLocalNetworkInterfaces(UserData userData, bool showHiddenCards = false,
bool showOnlyOperationalUp = true, string optionalAddress = "")
{
var interfaces = new List <LocalNetworkInterface>();
foreach (var nic in NetworkInterface.GetAllNetworkInterfaces())
{
if (showOnlyOperationalUp)
{
if (nic.OperationalStatus != OperationalStatus.Up)
{
continue;
}
}
if (!showHiddenCards)
{
var add = true;
foreach (var blacklistEntry in Global.NetworkInterfaceBlacklist)
{
if (nic.Description.Contains(blacklistEntry) || nic.Name.Contains(blacklistEntry))
{
add = false;
}
}
if (!add)
{
continue;
}
}
var localNetworkInterface = new LocalNetworkInterface
{
Name = nic.Name,
Description = nic.Description,
Type = nic.NetworkInterfaceType,
Ipv4Dns = GetDnsServerList(nic.Id, NetworkInterfaceComponent.IPv4),
Ipv6Dns = GetDnsServerList(nic.Id, NetworkInterfaceComponent.IPv6),
Ipv4Support = nic.Supports(NetworkInterfaceComponent.IPv4),
Ipv6Support = nic.Supports(NetworkInterfaceComponent.IPv6),
OperationalStatus = nic.OperationalStatus
};
localNetworkInterface.UseDnsCrypt = IsUsingDnsCrypt(localNetworkInterface, optionalAddress);
if (!localNetworkInterface.UseDnsCrypt)
{
localNetworkInterface.UseInsecureFallbackDns = IsUsingInsecureFallbackDns(localNetworkInterface, userData);
}
interfaces.Add(localNetworkInterface);
}
return(interfaces);
}
/// <summary>
/// Simple check if the network interface contains any of resolver addresses.
/// </summary>
/// <param name="listenAddresses"></param>
/// <param name="localNetworkInterface">The interface to check.</param>
/// <returns><c>true</c> if a address was found, otherwise <c>false</c></returns>
public static bool IsUsingDnsCrypt(List <string> listenAddresses, LocalNetworkInterface localNetworkInterface, bool strictCheck = false)
{
if (listenAddresses == null)
{
return(false);
}
var addressOnly = (from listenAddress in listenAddresses let lastIndex = listenAddress.LastIndexOf(":", StringComparison.Ordinal) select listenAddress.Substring(0, lastIndex).Replace("[", "").Replace("]", "")).ToList();
if (strictCheck)
{
// check for ALL addresses
return(addressOnly.Intersect(localNetworkInterface.Dns.Select(x => x.Address).ToList()).Count() == addressOnly.Count());
}
return(localNetworkInterface.Dns.Any(d => addressOnly.Contains(d.Address)));
}
/// <summary>
///
/// </summary>
/// <param name="localNetworkInterface"></param>
/// <param name="dnsServers"></param>
/// <returns></returns>
public static bool SetNameservers(LocalNetworkInterface localNetworkInterface, List <DnsServer> dnsServers)
{
try
{
if (dnsServers == null)
{
dnsServers = new List <DnsServer>();
}
using (var process = new Process())
{
var processStartInfoV4 = new ProcessStartInfo("netsh",
"interface ipv4 delete dns \"" + localNetworkInterface.Name + "\" all")
{
WindowStyle = ProcessWindowStyle.Hidden,
CreateNoWindow = true
};
process.StartInfo = processStartInfoV4;
process.Start();
var processStartInfoV6 = new ProcessStartInfo("netsh",
"interface ipv6 delete dns \"" + localNetworkInterface.Name + "\" all")
{
WindowStyle = ProcessWindowStyle.Hidden,
CreateNoWindow = true
};
process.StartInfo = processStartInfoV6;
process.Start();
foreach (var dnsServer in dnsServers)
{
if (dnsServer.Type == NetworkInterfaceComponent.IPv4)
{
var processStartInfo = new ProcessStartInfo("netsh",
"interface ipv4 add dns \"" + localNetworkInterface.Name + "\" " + dnsServer.Address + " validate=no")
{
WindowStyle = ProcessWindowStyle.Hidden,
CreateNoWindow = true
};
process.StartInfo = processStartInfo;
process.Start();
}
else
{
var processStartInfo = new ProcessStartInfo("netsh",
"interface ipv6 add dns \"" + localNetworkInterface.Name + "\" " + dnsServer.Address + " validate=no")
{
WindowStyle = ProcessWindowStyle.Hidden,
CreateNoWindow = true
};
process.StartInfo = processStartInfo;
process.Start();
}
}
}
return(true);
}
catch (Exception)
{
return(false);
}
}
/// <summary>
///
/// </summary>
/// <param name="localNetworkInterface"></param>
/// <param name="dnsServers"></param>
/// <returns></returns>
public static bool SetNameservers(LocalNetworkInterface localNetworkInterface, List <DnsServer> dnsServers)
{
var succedded = true;
try
{
if (dnsServers == null)
{
dnsServers = new List <DnsServer>();
}
var delete4 = ExecuteWithArguments("interface ipv4 delete dns \"" + localNetworkInterface.Name + "\" all");
if (delete4 != null)
{
if (!delete4.Success)
{
Logger.Warning("failed to delete DNS (IPv4)");
succedded = false;
}
else
{
Logger.Information("delete DNS (IPv4) succeeded");
}
}
else
{
Logger.Warning("failed to delete DNS (IPv4)");
succedded = false;
}
var delete6 = ExecuteWithArguments("interface ipv6 delete dns \"" + localNetworkInterface.Name + "\" all");
if (delete6 != null)
{
if (!delete6.Success)
{
Logger.Warning("failed to delete DNS (IPv6)");
succedded = false;
}
else
{
Logger.Information("delete DNS (IPv6) succeeded");
}
}
else
{
Logger.Warning("failed to delete DNS (IPv6)");
succedded = false;
}
foreach (var dnsServer in dnsServers)
{
if (dnsServer.Type == NetworkInterfaceComponent.IPv4)
{
var add4 = ExecuteWithArguments("interface ipv4 add dns \"" + localNetworkInterface.Name + "\" " + dnsServer.Address + " validate=no");
if (add4 != null)
{
if (!add4.Success)
{
Logger.Warning("failed to add DNS (IPv4)");
succedded = false;
}
else
{
Logger.Information("add DNS (IPv4) succeeded");
}
}
else
{
Logger.Warning("failed to add DNS (IPv4)");
succedded = false;
}
}
else
{
var add6 = ExecuteWithArguments("interface ipv6 add dns \"" + localNetworkInterface.Name + "\" " + dnsServer.Address + " validate=no");
if (add6 != null)
{
if (!add6.Success)
{
Logger.Warning("failed to add DNS (IPv6)");
succedded = false;
}
else
{
Logger.Information("add DNS (IPv6) succeeded");
}
}
else
{
Logger.Warning("failed to add DNS (IPv6)");
succedded = false;
}
}
}
}
catch (Exception exception)
{
Logger.Error(exception, "SetNameservers");
}
return(succedded);
}
public static bool UnsetNameservers(LocalNetworkInterface localNetworkInterface)
{
return(SetNameservers(localNetworkInterface, null));
}
/// <summary>
///
/// </summary>
/// <param name="localNetworkInterface"></param>
/// <param name="dnsServers"></param>
/// <returns></returns>
public static bool SetNameservers(LocalNetworkInterface localNetworkInterface, List <DnsServer> dnsServers)
{
try
{
if (dnsServers == null)
{
dnsServers = new List <DnsServer>();
}
var delete4 = ProcessHelper.ExecuteWithArguments("netsh", "interface ipv4 delete dns \"" + localNetworkInterface.Name + "\" all");
if (delete4 != null)
{
if (!delete4.Success)
{
Log.Warn("failed to delete DNS (IPv4)");
}
}
else
{
Log.Warn("failed to delete DNS (IPv4)");
}
var delete6 = ProcessHelper.ExecuteWithArguments("netsh", "interface ipv6 delete dns \"" + localNetworkInterface.Name + "\" all");
if (delete6 != null)
{
if (!delete6.Success)
{
Log.Warn("failed to delete DNS (IPv6)");
}
}
else
{
Log.Warn("failed to delete DNS (IPv6)");
}
foreach (var dnsServer in dnsServers)
{
if (dnsServer.Type == NetworkInterfaceComponent.IPv4)
{
var add4 = ProcessHelper.ExecuteWithArguments("netsh", "interface ipv4 add dns \"" + localNetworkInterface.Name + "\" " + dnsServer.Address + " validate=no");
if (add4 != null)
{
if (!add4.Success)
{
Log.Warn("failed to add DNS (IPv4)");
}
}
else
{
Log.Warn("failed to add DNS (IPv4)");
}
}
else
{
var add6 = ProcessHelper.ExecuteWithArguments("netsh", "interface ipv6 add dns \"" + localNetworkInterface.Name + "\" " + dnsServer.Address + " validate=no");
if (add6 != null)
{
if (!add6.Success)
{
Log.Warn("failed to add DNS (IPv6)");
}
}
else
{
Log.Warn("failed to add DNS (IPv6)");
}
}
}
return(true);
}
catch (Exception exception)
{
Log.Error(exception);
return(false);
}
}
/// <summary>
/// Set's the IPv4 or IPv6 DNS Servers of an interface.
/// </summary>
/// <param name="localNetworkInterface">The interface to work with.</param>
/// <param name="dnsServers">List of dns servers to set.</param>
/// <param name="networkInterfaceComponent">IPv4 or IPv6.</param>
/// <returns><c>true</c> on success, otherwise <c>false</c></returns>
/// <remarks>Win32_NetworkAdapter class is deprecated.
/// https://msdn.microsoft.com/en-us/library/windows/desktop/hh968170(v=vs.85).aspx (only on windows 8+)</remarks>
public static bool SetNameservers(LocalNetworkInterface localNetworkInterface, List <string> dnsServers,
NetworkInterfaceComponent networkInterfaceComponent = NetworkInterfaceComponent.IPv4)
{
var status = false;
if (networkInterfaceComponent == NetworkInterfaceComponent.IPv4)
{
using (var networkConfigMng = new ManagementClass("Win32_NetworkAdapterConfiguration"))
{
using (var networkConfigs = networkConfigMng.GetInstances())
{
//(bool)mo["IPEnabled"] &&
foreach (
var managementObject in
networkConfigs.Cast <ManagementObject>()
.Where(mo => (string)mo["Description"] == localNetworkInterface.Description))
{
var enabled = (bool)managementObject["IPEnabled"];
if (enabled)
{
// the network adapter is enabled, so we can change the dns settings per WMI.
using (var newDns = managementObject.GetMethodParameters("SetDNSServerSearchOrder"))
{
newDns["DNSServerSearchOrder"] = dnsServers.ToArray();
var outputBaseObject = managementObject.InvokeMethod("SetDNSServerSearchOrder", newDns, null);
if (outputBaseObject == null)
{
continue;
}
var state = (uint)outputBaseObject["returnValue"];
switch (state)
{
case 0: // Successful completion, no reboot required
case 1: // Successful completion, reboot required
status = true;
break;
case 84: // IP not enabled on adapter
status = false;
break;
default:
status = false;
break;
}
}
}
else
{
// seems to be unplugged or disabled, so we need change this per registry (not optimal)
var registryId = managementObject["SettingID"];
if (registryId == null)
{
continue;
}
var localMachine = Registry.LocalMachine;
var interfaceEntry = localMachine.OpenSubKey(
@"SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters\\Interfaces\\" + registryId, true);
if (interfaceEntry == null)
{
continue;
}
interfaceEntry.SetValue("NameServer", dnsServers.Count > 0 ? string.Join(",", dnsServers.ToArray()) : "",
RegistryValueKind.String);
status = true;
}
}
}
}
}
else
{
//TODO: find better way to set IPv6 nameservers
using (var process = new Process())
{
var processStartInfo = new ProcessStartInfo("netsh",
"interface ipv6 delete dns \"" + localNetworkInterface.Name + "\" all")
{
WindowStyle = ProcessWindowStyle.Hidden,
CreateNoWindow = true
};
process.StartInfo = processStartInfo;
process.Start();
foreach (var address in dnsServers)
{
//netsh interface ipv6 add dns "Interface Name" 127.0.0.1 validate=no
processStartInfo = new ProcessStartInfo("netsh",
"interface ipv6 add dns \"" + localNetworkInterface.Name + "\" " + address + " validate=no")
{
WindowStyle = ProcessWindowStyle.Hidden,
CreateNoWindow = true
};
process.StartInfo = processStartInfo;
process.Start();
}
status = true;
}
}
return(status);
}
/// <summary>
/// Click event for the network cards.
/// </summary>
/// <param name="localNetworkInterface">The clicked network card.</param>
public void NetworkCardClicked(LocalNetworkInterface localNetworkInterface)
{
if (localNetworkInterface == null) return;
if (localNetworkInterface.UseDnsCrypt)
{
var status = LocalNetworkInterfaceManager.SetNameservers(localNetworkInterface, new List<string>(),
NetworkInterfaceComponent.IPv4);
localNetworkInterface.UseDnsCrypt = !status;
}
else
{
var dns = new List<string>();
if (PrimaryResolver != null)
{
if (!string.IsNullOrEmpty(PrimaryResolver.ProviderPublicKey))
{
// only add the local address if the proxy is running
if (PrimaryDnsCryptProxyManager.DnsCryptProxy.IsReady && PrimaryDnsCryptProxyManager.IsDnsCryptProxyRunning())
{
dns.Add(Global.PrimaryResolverAddress);
}
}
}
if (SecondaryResolver != null)
{
if (!string.IsNullOrEmpty(SecondaryResolver.ProviderPublicKey))
{
// only add the local address if the proxy is running
if (SecondaryDnsCryptProxyManager.DnsCryptProxy.IsReady && SecondaryDnsCryptProxyManager.IsDnsCryptProxyRunning())
{
dns.Add(Global.SecondaryResolverAddress);
}
}
}
var status = LocalNetworkInterfaceManager.SetNameservers(localNetworkInterface, dns, NetworkInterfaceComponent.IPv4);
localNetworkInterface.UseDnsCrypt = status;
}
LoadNetworkCards();
}
/// <summary>
/// Simple check if the network interface contains any of resolver addresses.
/// </summary>
/// <param name="localNetworkInterface">The interface to check.</param>
/// <returns><c>true</c> if a address was found, otherwise <c>false</c></returns>
internal static bool IsUsingDnsCrypt(LocalNetworkInterface localNetworkInterface)
{
var dns = new List<string> {Global.PrimaryResolverAddress, Global.SecondaryResolverAddress};
var dns6 = new List<string> {Global.PrimaryResolverAddress6, Global.SecondaryResolverAddress6};
if (localNetworkInterface.Ipv4Dns.Contains(dns[0]) || localNetworkInterface.Ipv4Dns.Contains(dns[1]))
{
return true;
}
if (localNetworkInterface.Ipv6Dns.Contains(dns6[0]) || localNetworkInterface.Ipv6Dns.Contains(dns6[1]))
{
return true;
}
return false;
}
/// <summary>
/// Get a list of the local network interfaces.
/// </summary>
/// <param name="showHiddenCards">Show hidden cards.</param>
/// <param name="showOnlyOperationalUp">Include only connected network cards.</param>
/// <returns>A (filtered) list of the local network interfaces.</returns>
/// <exception cref="NetworkInformationException">A Windows system function call failed. </exception>
/// <exception cref="ArgumentNullException"></exception>
internal static List<LocalNetworkInterface> GetLocalNetworkInterfaces(bool showHiddenCards = false,
bool showOnlyOperationalUp = true)
{
var interfaces = new List<LocalNetworkInterface>();
foreach (var nic in NetworkInterface.GetAllNetworkInterfaces())
{
if (showOnlyOperationalUp)
{
if (nic.OperationalStatus != OperationalStatus.Up)
{
continue;
}
}
if (!showHiddenCards)
{
var add = true;
foreach (var blacklistEntry in Global.NetworkInterfaceBlacklist)
{
if (nic.Description.Contains(blacklistEntry) || nic.Name.Contains(blacklistEntry))
{
add = false;
}
}
if (!add) continue;
}
var localNetworkInterface = new LocalNetworkInterface
{
Name = nic.Name,
Description = nic.Description,
Type = nic.NetworkInterfaceType,
Ipv4Dns = GetDnsServerList(nic.Id, NetworkInterfaceComponent.IPv4),
Ipv6Dns = GetDnsServerList(nic.Id, NetworkInterfaceComponent.IPv6),
Ipv4Support = nic.Supports(NetworkInterfaceComponent.IPv4),
Ipv6Support = nic.Supports(NetworkInterfaceComponent.IPv6),
OperationalStatus = nic.OperationalStatus
};
localNetworkInterface.UseDnsCrypt = IsUsingDnsCrypt(localNetworkInterface);
interfaces.Add(localNetworkInterface);
}
return interfaces;
}
/// <summary>
/// Click event for the network cards.
/// </summary>
/// <param name="localNetworkInterface">The clicked network card.</param>
public void NetworkCardClicked(LocalNetworkInterface localNetworkInterface)
{
if (localNetworkInterface == null) return;
if (localNetworkInterface.UseDnsCrypt)
{
LocalNetworkInterfaceManager.SetNameservers(localNetworkInterface, new List<string>(),
NetworkInterfaceComponent.IPv4);
localNetworkInterface.UseDnsCrypt = false;
}
else
{
var dns = new List<string>();
if (PrimaryResolver != null)
{
if (!string.IsNullOrEmpty(PrimaryResolver.ProviderPublicKey))
{
if (PrimaryDnsCryptProxyManager.DnsCryptProxy.IsReady)
{
dns.Add(Global.PrimaryResolverAddress);
}
}
}
if (SecondaryResolver != null)
{
if (!string.IsNullOrEmpty(SecondaryResolver.ProviderPublicKey))
{
if (SecondaryDnsCryptProxyManager.DnsCryptProxy.IsReady)
{
dns.Add(Global.SecondaryResolverAddress);
}
}
}
LocalNetworkInterfaceManager.SetNameservers(localNetworkInterface, dns, NetworkInterfaceComponent.IPv4);
localNetworkInterface.UseDnsCrypt = true;
}
}
/// <summary>
/// Set's the IPv4 or IPv6 DNS Servers of an interface.
/// </summary>
/// <param name="localNetworkInterface">The interface to work with.</param>
/// <param name="dnsServers">List of dns servers to set.</param>
/// <param name="networkInterfaceComponent">IPv4 or IPv6.</param>
/// <returns><c>true</c> on success, otherwise <c>false</c></returns>
/// <remarks>Win32_NetworkAdapter class is deprecated.
/// https://msdn.microsoft.com/en-us/library/windows/desktop/hh968170(v=vs.85).aspx (only on windows 8+)</remarks>
public static bool SetNameservers(LocalNetworkInterface localNetworkInterface, List<string> dnsServers,
NetworkInterfaceComponent networkInterfaceComponent = NetworkInterfaceComponent.IPv4)
{
var status = false;
if (networkInterfaceComponent == NetworkInterfaceComponent.IPv4)
{
using (var networkConfigMng = new ManagementClass("Win32_NetworkAdapterConfiguration"))
{
using (var networkConfigs = networkConfigMng.GetInstances())
{
//(bool)mo["IPEnabled"] &&
foreach (
var managementObject in
networkConfigs.Cast<ManagementObject>()
.Where(mo => (string)mo["Description"] == localNetworkInterface.Description))
{
var enabled = (bool)managementObject["IPEnabled"];
if (enabled)
{
// the network adapter is enabled, so we can change the dns settings per WMI.
using (var newDns = managementObject.GetMethodParameters("SetDNSServerSearchOrder"))
{
newDns["DNSServerSearchOrder"] = dnsServers.ToArray();
var outputBaseObject = managementObject.InvokeMethod("SetDNSServerSearchOrder", newDns, null);
if (outputBaseObject == null) continue;
var state = (uint)outputBaseObject["returnValue"];
switch (state)
{
case 0: // Successful completion, no reboot required
case 1: // Successful completion, reboot required
status = true;
break;
case 84: // IP not enabled on adapter
status = false;
break;
default:
status = false;
break;
}
}
}
else
{
// seems to be unplugged or disabled, so we need change this per registry (not optimal)
var registryId = managementObject["SettingID"];
if (registryId == null) continue;
var localMachine = Registry.LocalMachine;
var interfaceEntry = localMachine.OpenSubKey(
@"SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters\\Interfaces\\" + registryId, true);
if (interfaceEntry == null) continue;
interfaceEntry.SetValue("NameServer", dnsServers.Count > 0 ? string.Join(",", dnsServers.ToArray()) : "",
RegistryValueKind.String);
status = true;
}
}
}
}
}
else
{
//TODO: find better way to set IPv6 nameservers
using (var process = new Process())
{
var processStartInfo = new ProcessStartInfo("netsh",
"interface ipv6 delete dns \"" + localNetworkInterface.Name + "\" all")
{
WindowStyle = ProcessWindowStyle.Hidden,
CreateNoWindow = true
};
process.StartInfo = processStartInfo;
process.Start();
foreach (var address in dnsServers)
{
//netsh interface ipv6 add dns "Interface Name" 127.0.0.1 validate=no
processStartInfo = new ProcessStartInfo("netsh",
"interface ipv6 add dns \"" + localNetworkInterface.Name + "\" " + address + " validate=no")
{
WindowStyle = ProcessWindowStyle.Hidden,
CreateNoWindow = true
};
process.StartInfo = processStartInfo;
process.Start();
}
status = true;
}
}
return status;
}
