2020-10-31 14:21:46 -04:00
using System ;
2021-03-08 21:04:47 -05:00
using System.Collections.ObjectModel ;
2020-10-31 14:21:46 -04:00
using System.Net ;
using Jellyfin.Networking.Configuration ;
using Jellyfin.Networking.Manager ;
using MediaBrowser.Common.Configuration ;
using MediaBrowser.Common.Net ;
using Microsoft.Extensions.Logging.Abstractions ;
2021-03-08 21:04:47 -05:00
using Moq ;
2020-10-31 14:21:46 -04:00
using Xunit ;
2020-11-21 11:08:19 -05:00
namespace Jellyfin.Networking.Tests
2020-10-31 14:21:46 -04:00
{
2020-11-21 11:03:25 -05:00
public class NetworkParseTests
2020-10-31 14:21:46 -04:00
{
2021-03-23 12:39:55 -04:00
internal static IConfigurationManager GetMockConfig ( NetworkConfiguration conf )
2020-10-31 14:21:46 -04:00
{
var configManager = new Mock < IConfigurationManager >
{
CallBase = true
} ;
configManager . Setup ( x = > x . GetConfiguration ( It . IsAny < string > ( ) ) ) . Returns ( conf ) ;
return ( IConfigurationManager ) configManager . Object ;
}
2020-11-21 15:31:24 -05:00
/// <summary>
2021-02-21 08:31:59 -05:00
/// Checks the ability to ignore virtual interfaces.
2020-11-21 15:31:24 -05:00
/// </summary>
2021-01-06 15:30:57 -05:00
/// <param name="interfaces">Mock network setup, in the format (IP address, interface index, interface name) | .... </param>
2020-11-21 15:31:24 -05:00
/// <param name="lan">LAN addresses.</param>
/// <param name="value">Bind addresses that are excluded.</param>
2020-10-31 14:21:46 -04:00
[Theory]
2021-02-21 08:31:59 -05:00
// All valid
[InlineData("192.168.1.208/24,-16,eth16|200.200.200.200/24,11,eth11", "192.168.1.0/24;200.200.200.0/24", "[192.168.1.208/24,200.200.200.200/24] ")]
// eth16 only
[InlineData("192.168.1.208/24,-16,eth16|200.200.200.200/24,11,eth11", "192.168.1.0/24", "[192.168.1.208/24] ")]
2021-04-14 05:26:05 -04:00
// All interfaces excluded. (including loopbacks)
2021-05-01 12:21:14 -04:00
[InlineData("192.168.1.208/24,-16,vEthernet1|192.168.2.208/24,-16,vEthernet212|200.200.200.200/24,11,eth11", "192.168.1.0/24", "[] ")]
2021-02-21 08:31:59 -05:00
// vEthernet1 and vEthernet212 should be excluded.
2021-05-01 12:21:14 -04:00
[InlineData("192.168.1.200/24,-20,vEthernet1|192.168.2.208/24,-16,vEthernet212|200.200.200.200/24,11,eth11", "192.168.1.0/24;200.200.200.200/24", "[200.200.200.200/24] ")]
2021-03-08 19:07:21 -05:00
// Overlapping interface,
[InlineData("192.168.1.110/24,-20,br0|192.168.1.10/24,-16,br0|200.200.200.200/24,11,eth11", "192.168.1.0/24", "[192.168.1.110/24,192.168.1.10/24] ")]
2020-10-31 14:21:46 -04:00
public void IgnoreVirtualInterfaces ( string interfaces , string lan , string value )
{
var conf = new NetworkConfiguration ( )
{
EnableIPV6 = true ,
EnableIPV4 = true ,
2020-11-16 12:30:27 -05:00
LocalNetworkSubnets = lan ? . Split ( ';' ) ? ? throw new ArgumentNullException ( nameof ( lan ) )
2020-10-31 14:21:46 -04:00
} ;
NetworkManager . MockNetworkSettings = interfaces ;
2020-11-16 12:30:27 -05:00
using var nm = new NetworkManager ( GetMockConfig ( conf ) , new NullLogger < NetworkManager > ( ) ) ;
2020-10-31 14:21:46 -04:00
NetworkManager . MockNetworkSettings = string . Empty ;
2020-11-21 15:05:11 -05:00
Assert . Equal ( nm . GetInternalBindAddresses ( ) . AsString ( ) , value ) ;
2020-10-31 14:21:46 -04:00
}
2020-11-21 15:31:24 -05:00
/// <summary>
/// Test collection parsing.
/// </summary>
/// <param name="settings">Collection to parse.</param>
/// <param name="result1">Included addresses from the collection.</param>
/// <param name="result2">Included IP4 addresses from the collection.</param>
/// <param name="result3">Excluded addresses from the collection.</param>
/// <param name="result4">Excluded IP4 addresses from the collection.</param>
/// <param name="result5">Network addresses of the collection.</param>
2020-10-31 14:21:46 -04:00
[Theory]
2021-03-08 21:04:47 -05:00
[ InlineData (
"127.0.0.1#" ,
2020-10-31 14:21:46 -04:00
"[]" ,
"[]" ,
"[]" ,
"[]" ,
"[]" ) ]
2021-03-08 21:04:47 -05:00
[ InlineData (
"!127.0.0.1" ,
2020-10-31 14:21:46 -04:00
"[]" ,
"[]" ,
"[127.0.0.1/32]" ,
"[127.0.0.1/32]" ,
"[]" ) ]
2021-03-08 21:04:47 -05:00
[ InlineData (
"" ,
2020-10-31 14:21:46 -04:00
"[]" ,
"[]" ,
"[]" ,
"[]" ,
"[]" ) ]
2020-11-24 00:11:02 -05:00
[ InlineData (
"192.158.1.2/16, localhost, fd23:184f:2029:0:3139:7386:67d7:d517, !10.10.10.10" ,
2021-02-07 12:42:23 -05:00
"[192.158.1.2/16,[127.0.0.1/32,::1/128],fd23:184f:2029:0:3139:7386:67d7:d517/128]" ,
2020-11-24 00:11:02 -05:00
"[192.158.1.2/16,127.0.0.1/32]" ,
"[10.10.10.10/32]" ,
"[10.10.10.10/32]" ,
2021-02-07 12:42:23 -05:00
"[192.158.0.0/16,127.0.0.1/32,::1/128,fd23:184f:2029:0:3139:7386:67d7:d517/128]" ) ]
2021-03-08 21:04:47 -05:00
[ InlineData (
"192.158.1.2/255.255.0.0,192.169.1.2/8" ,
2020-10-31 14:21:46 -04:00
"[192.158.1.2/16,192.169.1.2/8]" ,
"[192.158.1.2/16,192.169.1.2/8]" ,
"[]" ,
"[]" ,
"[192.158.0.0/16,192.0.0.0/8]" ) ]
public void TestCollections ( string settings , string result1 , string result2 , string result3 , string result4 , string result5 )
{
2020-11-16 12:30:27 -05:00
if ( settings = = null )
{
throw new ArgumentNullException ( nameof ( settings ) ) ;
}
2020-10-31 14:21:46 -04:00
var conf = new NetworkConfiguration ( )
{
EnableIPV6 = true ,
EnableIPV4 = true ,
2021-03-08 21:04:47 -05:00
} ;
2020-10-31 14:21:46 -04:00
2020-11-16 12:30:27 -05:00
using var nm = new NetworkManager ( GetMockConfig ( conf ) , new NullLogger < NetworkManager > ( ) ) ;
2020-10-31 14:21:46 -04:00
2020-11-21 15:31:24 -05:00
// Test included.
2021-03-27 04:16:48 -04:00
Collection < IPObject > nc = nm . CreateIPCollection ( settings . Split ( ',' ) , false ) ;
2020-11-21 15:01:58 -05:00
Assert . Equal ( nc . AsString ( ) , result1 ) ;
2020-10-31 14:21:46 -04:00
2020-11-21 15:31:24 -05:00
// Test excluded.
2021-03-27 04:16:48 -04:00
nc = nm . CreateIPCollection ( settings . Split ( ',' ) , true ) ;
2020-11-21 15:02:36 -05:00
Assert . Equal ( nc . AsString ( ) , result3 ) ;
2020-10-31 14:21:46 -04:00
conf . EnableIPV6 = false ;
nm . UpdateSettings ( conf ) ;
2021-03-08 21:04:47 -05:00
2020-11-21 15:31:24 -05:00
// Test IP4 included.
2021-03-27 04:16:48 -04:00
nc = nm . CreateIPCollection ( settings . Split ( ',' ) , false ) ;
2020-11-21 15:05:31 -05:00
Assert . Equal ( nc . AsString ( ) , result2 ) ;
2020-10-31 14:21:46 -04:00
2020-11-21 15:31:24 -05:00
// Test IP4 excluded.
2021-03-27 04:16:48 -04:00
nc = nm . CreateIPCollection ( settings . Split ( ',' ) , true ) ;
2020-11-21 15:04:02 -05:00
Assert . Equal ( nc . AsString ( ) , result4 ) ;
2020-10-31 14:21:46 -04:00
conf . EnableIPV6 = true ;
nm . UpdateSettings ( conf ) ;
// Test network addresses of collection.
2021-03-27 04:16:48 -04:00
nc = nm . CreateIPCollection ( settings . Split ( ',' ) , false ) ;
2020-10-31 14:21:46 -04:00
nc = nc . AsNetworks ( ) ;
2020-11-21 15:04:16 -05:00
Assert . Equal ( nc . AsString ( ) , result5 ) ;
2020-10-31 14:21:46 -04:00
}
2020-11-21 15:31:24 -05:00
/// <summary>
/// Union two collections.
/// </summary>
/// <param name="settings">Source.</param>
/// <param name="compare">Destination.</param>
/// <param name="result">Result.</param>
2020-10-31 14:21:46 -04:00
[Theory]
[InlineData("127.0.0.1", "fd23:184f:2029:0:3139:7386:67d7:d517/64,fd23:184f:2029:0:c0f0:8a8a:7605:fffa/128,fe80::3139:7386:67d7:d517%16/64,192.168.1.208/24,::1/128,127.0.0.1/8", "[127.0.0.1/32] ")]
[InlineData("127.0.0.1", "127.0.0.1/8", "[127.0.0.1/32] ")]
public void UnionCheck ( string settings , string compare , string result )
{
2020-11-16 12:30:27 -05:00
if ( settings = = null )
{
throw new ArgumentNullException ( nameof ( settings ) ) ;
}
if ( compare = = null )
{
throw new ArgumentNullException ( nameof ( compare ) ) ;
}
if ( result = = null )
{
throw new ArgumentNullException ( nameof ( result ) ) ;
}
2020-10-31 14:21:46 -04:00
var conf = new NetworkConfiguration ( )
{
EnableIPV6 = true ,
EnableIPV4 = true ,
} ;
2020-11-16 12:30:27 -05:00
using var nm = new NetworkManager ( GetMockConfig ( conf ) , new NullLogger < NetworkManager > ( ) ) ;
2020-10-31 14:21:46 -04:00
2021-03-27 04:16:48 -04:00
Collection < IPObject > nc1 = nm . CreateIPCollection ( settings . Split ( ',' ) , false ) ;
Collection < IPObject > nc2 = nm . CreateIPCollection ( compare . Split ( ',' ) , false ) ;
2020-10-31 14:21:46 -04:00
2021-04-14 05:26:05 -04:00
Assert . Equal ( nc1 . ThatAreContainedInNetworks ( nc2 ) . AsString ( ) , result ) ;
2020-10-31 14:21:46 -04:00
}
[Theory]
[InlineData("192.168.5.85/24", "192.168.5.1")]
[InlineData("192.168.5.85/24", "192.168.5.254")]
[InlineData("10.128.240.50/30", "10.128.240.48")]
[InlineData("10.128.240.50/30", "10.128.240.49")]
[InlineData("10.128.240.50/30", "10.128.240.50")]
[InlineData("10.128.240.50/30", "10.128.240.51")]
[InlineData("127.0.0.1/8", "127.0.0.1")]
public void IpV4SubnetMaskMatchesValidIpAddress ( string netMask , string ipAddress )
{
var ipAddressObj = IPNetAddress . Parse ( netMask ) ;
Assert . True ( ipAddressObj . Contains ( IPAddress . Parse ( ipAddress ) ) ) ;
}
[Theory]
[InlineData("192.168.5.85/24", "192.168.4.254")]
[InlineData("192.168.5.85/24", "191.168.5.254")]
[InlineData("10.128.240.50/30", "10.128.240.47")]
[InlineData("10.128.240.50/30", "10.128.240.52")]
[InlineData("10.128.240.50/30", "10.128.239.50")]
[InlineData("10.128.240.50/30", "10.127.240.51")]
public void IpV4SubnetMaskDoesNotMatchInvalidIpAddress ( string netMask , string ipAddress )
{
var ipAddressObj = IPNetAddress . Parse ( netMask ) ;
Assert . False ( ipAddressObj . Contains ( IPAddress . Parse ( ipAddress ) ) ) ;
}
[Theory]
[InlineData("2001:db8:abcd:0012::0/64", "2001:0DB8:ABCD:0012:0000:0000:0000:0000")]
[InlineData("2001:db8:abcd:0012::0/64", "2001:0DB8:ABCD:0012:FFFF:FFFF:FFFF:FFFF")]
[InlineData("2001:db8:abcd:0012::0/64", "2001:0DB8:ABCD:0012:0001:0000:0000:0000")]
[InlineData("2001:db8:abcd:0012::0/64", "2001:0DB8:ABCD:0012:FFFF:FFFF:FFFF:FFF0")]
[InlineData("2001:db8:abcd:0012::0/128", "2001:0DB8:ABCD:0012:0000:0000:0000:0000")]
public void IpV6SubnetMaskMatchesValidIpAddress ( string netMask , string ipAddress )
{
var ipAddressObj = IPNetAddress . Parse ( netMask ) ;
Assert . True ( ipAddressObj . Contains ( IPAddress . Parse ( ipAddress ) ) ) ;
}
[Theory]
[InlineData("2001:db8:abcd:0012::0/64", "2001:0DB8:ABCD:0011:FFFF:FFFF:FFFF:FFFF")]
[InlineData("2001:db8:abcd:0012::0/64", "2001:0DB8:ABCD:0013:0000:0000:0000:0000")]
[InlineData("2001:db8:abcd:0012::0/64", "2001:0DB8:ABCD:0013:0001:0000:0000:0000")]
[InlineData("2001:db8:abcd:0012::0/64", "2001:0DB8:ABCD:0011:FFFF:FFFF:FFFF:FFF0")]
[InlineData("2001:db8:abcd:0012::0/128", "2001:0DB8:ABCD:0012:0000:0000:0000:0001")]
public void IpV6SubnetMaskDoesNotMatchInvalidIpAddress ( string netMask , string ipAddress )
{
var ipAddressObj = IPNetAddress . Parse ( netMask ) ;
Assert . False ( ipAddressObj . Contains ( IPAddress . Parse ( ipAddress ) ) ) ;
}
[Theory]
[InlineData("10.0.0.0/255.0.0.0", "10.10.10.1/32")]
[InlineData("10.0.0.0/8", "10.10.10.1/32")]
[InlineData("10.0.0.0/255.0.0.0", "10.10.10.1")]
[InlineData("10.10.0.0/255.255.0.0", "10.10.10.1/32")]
[InlineData("10.10.0.0/16", "10.10.10.1/32")]
[InlineData("10.10.0.0/255.255.0.0", "10.10.10.1")]
[InlineData("10.10.10.0/255.255.255.0", "10.10.10.1/32")]
[InlineData("10.10.10.0/24", "10.10.10.1/32")]
[InlineData("10.10.10.0/255.255.255.0", "10.10.10.1")]
2020-11-21 15:31:24 -05:00
public void TestSubnetContains ( string network , string ip )
2020-10-31 14:21:46 -04:00
{
2021-02-07 12:42:23 -05:00
Assert . True ( IPNetAddress . TryParse ( network , out var networkObj ) ) ;
Assert . True ( IPNetAddress . TryParse ( ip , out var ipObj ) ) ;
2020-10-31 14:21:46 -04:00
Assert . True ( networkObj . Contains ( ipObj ) ) ;
}
[Theory]
[InlineData("192.168.1.2/24,10.10.10.1/24,172.168.1.2/24", "172.168.1.2/24", "172.168.1.2/24")]
[InlineData("192.168.1.2/24,10.10.10.1/24,172.168.1.2/24", "172.168.1.2/24, 10.10.10.1", "172.168.1.2/24,10.10.10.1/24")]
[InlineData("192.168.1.2/24,10.10.10.1/24,172.168.1.2/24", "192.168.1.2/255.255.255.0, 10.10.10.1", "192.168.1.2/24,10.10.10.1/24")]
[InlineData("192.168.1.2/24,10.10.10.1/24,172.168.1.2/24", "192.168.1.2/24, 100.10.10.1", "192.168.1.2/24")]
[InlineData("192.168.1.2/24,10.10.10.1/24,172.168.1.2/24", "194.168.1.2/24, 100.10.10.1", "")]
2020-11-21 15:31:24 -05:00
public void TestCollectionEquality ( string source , string dest , string result )
2020-10-31 14:21:46 -04:00
{
2020-11-16 12:30:27 -05:00
if ( source = = null )
{
throw new ArgumentNullException ( nameof ( source ) ) ;
}
if ( dest = = null )
{
throw new ArgumentNullException ( nameof ( dest ) ) ;
}
if ( result = = null )
{
throw new ArgumentNullException ( nameof ( result ) ) ;
}
2020-10-31 14:21:46 -04:00
var conf = new NetworkConfiguration ( )
{
EnableIPV6 = true ,
EnableIPV4 = true
} ;
2020-11-16 12:30:27 -05:00
using var nm = new NetworkManager ( GetMockConfig ( conf ) , new NullLogger < NetworkManager > ( ) ) ;
2020-10-31 14:21:46 -04:00
// Test included, IP6.
2021-03-27 04:16:48 -04:00
Collection < IPObject > ncSource = nm . CreateIPCollection ( source . Split ( ',' ) ) ;
Collection < IPObject > ncDest = nm . CreateIPCollection ( dest . Split ( ',' ) ) ;
2021-04-14 05:26:05 -04:00
Collection < IPObject > ncResult = ncSource . ThatAreContainedInNetworks ( ncDest ) ;
2021-03-27 04:16:48 -04:00
Collection < IPObject > resultCollection = nm . CreateIPCollection ( result . Split ( ',' ) ) ;
2020-10-31 15:16:28 -04:00
Assert . True ( ncResult . Compare ( resultCollection ) ) ;
2020-10-31 14:21:46 -04:00
}
[Theory]
[InlineData("10.1.1.1/32", "10.1.1.1")]
[InlineData("192.168.1.254/32", "192.168.1.254/255.255.255.255")]
public void TestEquals ( string source , string dest )
{
Assert . True ( IPNetAddress . Parse ( source ) . Equals ( IPNetAddress . Parse ( dest ) ) ) ;
Assert . True ( IPNetAddress . Parse ( dest ) . Equals ( IPNetAddress . Parse ( source ) ) ) ;
}
[Theory]
2020-11-21 15:31:24 -05:00
// Testing bind interfaces.
2020-10-31 14:21:46 -04:00
// On my system eth16 is internal, eth11 external (Windows defines the indexes).
//
// This test is to replicate how DNLA requests work throughout the system.
// User on internal network, we're bound internal and external - so result is internal.
[InlineData("192.168.1.1", "eth16,eth11", false, "eth16")]
// User on external network, we're bound internal and external - so result is external.
[InlineData("8.8.8.8", "eth16,eth11", false, "eth11")]
// User on internal network, we're bound internal only - so result is internal.
[InlineData("10.10.10.10", "eth16", false, "eth16")]
// User on internal network, no binding specified - so result is the 1st internal.
[InlineData("192.168.1.1", "", false, "eth16")]
// User on external network, internal binding only - so result is the 1st internal.
[InlineData("jellyfin.org", "eth16", false, "eth16")]
// User on external network, no binding - so result is the 1st external.
[InlineData("jellyfin.org", "", false, "eth11")]
2021-04-10 14:44:09 -04:00
// Dns failure - should skip the test.
2021-04-12 05:28:24 -04:00
// https://en.wikipedia.org/wiki/.test
[InlineData("invalid.domain.test", "", false, "eth11")]
2020-10-31 14:21:46 -04:00
// User assumed to be internal, no binding - so result is the 1st internal.
[InlineData("", "", false, "eth16")]
public void TestBindInterfaces ( string source , string bindAddresses , bool ipv6enabled , string result )
{
2020-11-16 12:30:27 -05:00
if ( source = = null )
{
throw new ArgumentNullException ( nameof ( source ) ) ;
}
if ( bindAddresses = = null )
{
throw new ArgumentNullException ( nameof ( bindAddresses ) ) ;
}
if ( result = = null )
{
throw new ArgumentNullException ( nameof ( result ) ) ;
}
2020-10-31 14:21:46 -04:00
var conf = new NetworkConfiguration ( )
{
LocalNetworkAddresses = bindAddresses . Split ( ',' ) ,
EnableIPV6 = ipv6enabled ,
EnableIPV4 = true
} ;
2021-01-06 15:30:57 -05:00
NetworkManager . MockNetworkSettings = "192.168.1.208/24,-16,eth16|200.200.200.200/24,11,eth11" ;
2020-11-16 12:30:27 -05:00
using var nm = new NetworkManager ( GetMockConfig ( conf ) , new NullLogger < NetworkManager > ( ) ) ;
2020-10-31 14:21:46 -04:00
NetworkManager . MockNetworkSettings = string . Empty ;
2020-11-21 11:14:00 -05:00
_ = nm . TryParseInterface ( result , out Collection < IPObject > ? resultObj ) ;
2020-10-31 14:21:46 -04:00
2021-04-10 14:44:09 -04:00
// Check to see if dns resolution is working. If not, skip test.
_ = IPHost . TryParse ( source , out var host ) ;
if ( resultObj ! = null & & host ? . HasAddress = = true )
2020-10-31 14:21:46 -04:00
{
result = ( ( IPNetAddress ) resultObj [ 0 ] ) . ToString ( true ) ;
2021-04-10 14:44:09 -04:00
var intf = nm . GetBindInterface ( source , out _ ) ;
2020-10-31 14:21:46 -04:00
2020-11-21 15:02:19 -05:00
Assert . Equal ( intf , result ) ;
2020-10-31 14:21:46 -04:00
}
}
[Theory]
// Testing bind interfaces. These are set for my system so won't work elsewhere.
// On my system eth16 is internal, eth11 external (Windows defines the indexes).
//
// This test is to replicate how subnet bound ServerPublisherUri work throughout the system.
2021-03-08 21:04:47 -05:00
2020-10-31 14:21:46 -04:00
// User on internal network, we're bound internal and external - so result is internal override.
[InlineData("192.168.1.1", "192.168.1.0/24", "eth16,eth11", false, "192.168.1.0/24=internal.jellyfin", "internal.jellyfin")]
// User on external network, we're bound internal and external - so result is override.
[InlineData("8.8.8.8", "192.168.1.0/24", "eth16,eth11", false, "0.0.0.0=http://helloworld.com", "http://helloworld.com")]
// User on internal network, we're bound internal only, but the address isn't in the LAN - so return the override.
[InlineData("10.10.10.10", "192.168.1.0/24", "eth16", false, "0.0.0.0=http://internalButNotDefinedAsLan.com", "http://internalButNotDefinedAsLan.com")]
// User on internal network, no binding specified - so result is the 1st internal.
[InlineData("192.168.1.1", "192.168.1.0/24", "", false, "0.0.0.0=http://helloworld.com", "eth16")]
2021-02-07 12:42:23 -05:00
// User on external network, internal binding only - so assumption is a proxy forward, return external override.
2020-10-31 14:21:46 -04:00
[InlineData("jellyfin.org", "192.168.1.0/24", "eth16", false, "0.0.0.0=http://helloworld.com", "http://helloworld.com")]
// User on external network, no binding - so result is the 1st external which is overriden.
[InlineData("jellyfin.org", "192.168.1.0/24", "", false, "0.0.0.0 = http://helloworld.com", "http://helloworld.com")]
// User assumed to be internal, no binding - so result is the 1st internal.
[InlineData("", "192.168.1.0/24", "", false, "0.0.0.0=http://helloworld.com", "eth16")]
// User is internal, no binding - so result is the 1st internal, which is then overridden.
[InlineData("192.168.1.1", "192.168.1.0/24", "", false, "eth16=http://helloworld.com", "http://helloworld.com")]
public void TestBindInterfaceOverrides ( string source , string lan , string bindAddresses , bool ipv6enabled , string publishedServers , string result )
{
2020-11-16 12:30:27 -05:00
if ( lan = = null )
{
throw new ArgumentNullException ( nameof ( lan ) ) ;
}
if ( bindAddresses = = null )
{
throw new ArgumentNullException ( nameof ( bindAddresses ) ) ;
}
2020-10-31 14:21:46 -04:00
var conf = new NetworkConfiguration ( )
{
LocalNetworkSubnets = lan . Split ( ',' ) ,
LocalNetworkAddresses = bindAddresses . Split ( ',' ) ,
EnableIPV6 = ipv6enabled ,
EnableIPV4 = true ,
PublishedServerUriBySubnet = new string [ ] { publishedServers }
} ;
2021-01-06 15:30:57 -05:00
NetworkManager . MockNetworkSettings = "192.168.1.208/24,-16,eth16|200.200.200.200/24,11,eth11" ;
2020-11-16 12:30:27 -05:00
using var nm = new NetworkManager ( GetMockConfig ( conf ) , new NullLogger < NetworkManager > ( ) ) ;
2020-10-31 14:21:46 -04:00
NetworkManager . MockNetworkSettings = string . Empty ;
2020-11-21 11:14:00 -05:00
if ( nm . TryParseInterface ( result , out Collection < IPObject > ? resultObj ) & & resultObj ! = null )
2020-10-31 14:21:46 -04:00
{
// Parse out IPAddresses so we can do a string comparison. (Ignore subnet masks).
result = ( ( IPNetAddress ) resultObj [ 0 ] ) . ToString ( true ) ;
}
var intf = nm . GetBindInterface ( source , out int? _ ) ;
2020-11-21 15:00:17 -05:00
Assert . Equal ( intf , result ) ;
2020-10-31 14:21:46 -04:00
}
2021-03-11 16:36:58 -05:00
[Theory]
2021-03-11 17:47:30 -05:00
[InlineData("185.10.10.10,200.200.200.200", "79.2.3.4", true)]
[InlineData("185.10.10.10", "185.10.10.10", false)]
2021-03-22 13:04:09 -04:00
[InlineData("", "100.100.100.100", false)]
public void HasRemoteAccess_GivenWhitelist_AllowsOnlyIpsInWhitelist ( string addresses , string remoteIp , bool denied )
2021-03-11 16:36:58 -05:00
{
// Comma separated list of IP addresses or IP/netmask entries for networks that will be allowed to connect remotely.
// If left blank, all remote addresses will be allowed.
var conf = new NetworkConfiguration ( )
{
EnableIPV4 = true ,
2021-03-27 04:16:48 -04:00
RemoteIPFilter = addresses . Split ( ',' ) ,
2021-03-11 17:47:30 -05:00
IsRemoteIPFilterBlacklist = false
} ;
using var nm = new NetworkManager ( GetMockConfig ( conf ) , new NullLogger < NetworkManager > ( ) ) ;
Assert . NotEqual ( nm . HasRemoteAccess ( IPAddress . Parse ( remoteIp ) ) , denied ) ;
}
[Theory]
2021-03-22 13:04:09 -04:00
[InlineData("185.10.10.10", "79.2.3.4", false)]
[InlineData("185.10.10.10", "185.10.10.10", true)]
[InlineData("", "100.100.100.100", false)]
public void HasRemoteAccess_GivenBlacklist_BlacklistTheIps ( string addresses , string remoteIp , bool denied )
2021-03-11 17:47:30 -05:00
{
// Comma separated list of IP addresses or IP/netmask entries for networks that will be allowed to connect remotely.
// If left blank, all remote addresses will be allowed.
var conf = new NetworkConfiguration ( )
{
EnableIPV4 = true ,
2021-03-27 04:16:48 -04:00
RemoteIPFilter = addresses . Split ( ',' ) ,
2021-03-11 17:47:30 -05:00
IsRemoteIPFilterBlacklist = true
2021-03-11 16:36:58 -05:00
} ;
using var nm = new NetworkManager ( GetMockConfig ( conf ) , new NullLogger < NetworkManager > ( ) ) ;
Assert . NotEqual ( nm . HasRemoteAccess ( IPAddress . Parse ( remoteIp ) ) , denied ) ;
}
2021-04-24 18:54:48 -04:00
[Theory]
[InlineData("192.168.1.209/24,-16,eth16", "192.168.1.0/24", "", "192.168.1.209")] // Only 1 address so use it.
[InlineData("192.168.1.208/24,-16,eth16|10.0.0.1/24,10,eth7", "192.168.1.0/24", "", "192.168.1.208")] // LAN address is specified by default.
[InlineData("192.168.1.208/24,-16,eth16|10.0.0.1/24,10,eth7", "192.168.1.0/24", "10.0.0.1", "10.0.0.1")] // return bind address
public void Get_Appropriate_Interface_NoSource ( string interfaces , string lan , string bind , string result )
{
var conf = new NetworkConfiguration ( )
{
EnableIPV4 = true ,
LocalNetworkSubnets = lan . Split ( ',' ) ,
LocalNetworkAddresses = bind . Split ( ',' )
} ;
NetworkManager . MockNetworkSettings = interfaces ;
using var nm = new NetworkManager ( GetMockConfig ( conf ) , new NullLogger < NetworkManager > ( ) ) ;
2021-05-01 11:29:22 -04:00
var interfaceToUse = nm . GetBindInterface ( string . Empty , out _ ) ;
2021-04-24 18:54:48 -04:00
2021-05-01 11:29:13 -04:00
Assert . Equal ( result , interfaceToUse ) ;
2021-04-24 18:54:48 -04:00
}
[Theory]
[InlineData("192.168.1.209/24,-16,eth16", "192.168.1.0/24", "", "192.168.1.210", "192.168.1.209")] // Source on LAN
[InlineData("192.168.1.208/24,-16,eth16|10.0.0.1/24,10,eth7", "192.168.1.0/24", "", "192.168.1.209", "192.168.1.208")] // Source on LAN
[InlineData("192.168.1.208/24,-16,eth16|10.0.0.1/24,10,eth7", "192.168.1.0/24", "", "8.8.8.8", "10.0.0.1")] // Source external.
[InlineData("192.168.1.208/24,-16,eth16|10.0.0.1/24,10,eth7", "192.168.1.0/24", "10.0.0.1", "192.168.1.209", "10.0.0.1")] // LAN not bound, so return external.
[InlineData("192.168.1.208/24,-16,eth16|10.0.0.1/24,10,eth7", "192.168.1.0/24", "192.168.1.208,10.0.0.1", "8.8.8.8", "10.0.0.1")] // return external bind address
[InlineData("192.168.1.208/24,-16,eth16|10.0.0.1/24,10,eth7", "192.168.1.0/24", "192.168.1.208,10.0.0.1", "192.168.1.210", "192.168.1.208")] // return LAN bind address
public void Get_Appropriate_Interface_ForSource ( string interfaces , string lan , string bind , string source , string result )
{
var conf = new NetworkConfiguration ( )
{
EnableIPV4 = true ,
LocalNetworkSubnets = lan . Split ( ',' ) ,
LocalNetworkAddresses = bind . Split ( ',' )
} ;
NetworkManager . MockNetworkSettings = interfaces ;
using var nm = new NetworkManager ( GetMockConfig ( conf ) , new NullLogger < NetworkManager > ( ) ) ;
2021-05-01 11:29:28 -04:00
var interfaceToUse = nm . GetBindInterface ( source , out _ ) ;
2021-04-24 18:54:48 -04:00
2021-05-01 12:16:25 -04:00
Assert . Equal ( result , interfaceToUse ) ;
2021-04-24 18:54:48 -04:00
}
2020-10-31 14:21:46 -04:00
}
}