Boolean DialUp()
{
try {
using (var phoneBook = new RasPhoneBook()) {
var name = VpnConfig.GetConfig().ConnectionName;
var user = VpnConfig.GetConfig().Username;
var pass = VpnConfig.GetConfig().Password;
var pbPath = VpnConfig.GetConfig().PhoneBookPath;
phoneBook.Open(pbPath);
var entry = phoneBook.Entries.FirstOrDefault(e => e.Name.Equals(name));
if (entry != null)
{
using (var dialer = new RasDialer()) {
dialer.EntryName = name;
dialer.Credentials = new NetworkCredential(user, pass);
dialer.PhoneBookPath = pbPath;
dialer.Dial();
}
}
else
{
throw new ArgumentException(
message: "entry wasn't found: " + name,
paramName: "entry"
);
}
}
return(true);
}
catch {
// log the exception
return(false);
}
}
public void Connect(IReadOnlyList <VpnHost> servers, VpnConfig config, VpnProtocol protocol,
VpnCredentials credentials)
{
ApplyNetworkSettings();
_origin.Connect(servers, config, protocol, credentials);
}
public void DoesntWriteThePlainPasswordField()
{
var passwordInPlainText = "Password-in-plain-text";
var vpnConfig = new VpnConfig()
{
UserName = "******",
Password = passwordInPlainText,
};
var jsonSerializerOptions = new JsonSerializerOptions {
WriteIndented = true,
Converters =
{
new VpnConfigConverter()
},
};
string result = JsonSerializer.Serialize(vpnConfig, jsonSerializerOptions);
result.Should().NotContain(passwordInPlainText);
result.Should().Contain(vpnConfig.PasswordEncoded);
result.Should().NotContain($@"""{nameof(VpnConfig.Password)}""");
result.Should().Contain($@"""{nameof(VpnConfig.PasswordEncoded)}""");
}
public void Connect(IReadOnlyList <VpnHost> servers, VpnConfig config, VpnProtocol protocol,
VpnCredentials credentials)
{
AddDefaultGateway();
_origin.Connect(servers, config, protocol, credentials);
}
public void Connect(VpnEndpoint endpoint, VpnCredentials credentials, VpnConfig config)
{
_config = config;
_endpoint = endpoint;
_credentials = credentials;
_connectAction.Run();
}
public void TestInitialize()
{
_logger = Substitute.For <ILogger>();
_taskQueue = new TaskQueue();
_origin = Substitute.For <ISingleVpnConnection>();
_endpoint = new VpnEndpoint(new VpnHost("proton.vpn", "135.27.46.203", string.Empty), VpnProtocol.OpenVpnTcp, 777);
_credentials = new VpnCredentials("username", "password");
_config = new VpnConfig(new Dictionary <VpnProtocol, IReadOnlyCollection <int> >(), SplitTunnelMode.Disabled, useTunAdapter: false);
}
public async Task UpdateServers(IReadOnlyList <VpnHost> servers, VpnConfig config)
{
Ensure.NotNull(servers, nameof(servers));
Ensure.NotNull(config, nameof(config));
VpnHostContract[] endpointIpsContract = Map(servers);
VpnConfigContract configContract = Map(config);
await _vpnService.UpdateServers(endpointIpsContract, configContract);
}
public void TestInitialize()
{
_logger = Substitute.For <ILogger>();
_taskQueue = new TaskQueue();
_origin = Substitute.For <ISingleVpnConnection>();
_endpoint = new VpnEndpoint(new VpnHost("proton.vpn", "135.27.46.203"), VpnProtocol.OpenVpnTcp, 777);
_credentials = new VpnCredentials("username", "password");
_config = new VpnConfig(new Dictionary <VpnProtocol, IReadOnlyCollection <int> >(), new List <string>());
}
private static VpnConfigContract Map(VpnConfig config)
{
var portConfig = config.Ports.ToDictionary(p => Map(p.Key), p => p.Value.ToArray());
return(new VpnConfigContract
{
Ports = portConfig,
CustomDns = config.CustomDns.ToList(),
});
}
public VpnConnectionRequest(
IReadOnlyList <VpnHost> servers,
VpnProtocol protocol,
VpnConfig config,
VpnCredentials credentials)
{
Servers = servers;
Protocol = protocol;
Config = config;
Credentials = credentials;
}
public void Connect(IReadOnlyList <VpnHost> servers, VpnConfig config, VpnCredentials credentials)
{
_servers = servers;
_config = config;
_credentials = credentials;
_connectRequested = true;
_disconnectedReceived = false;
Queued(Connect);
}
public void UpdateServers(IReadOnlyList <VpnHost> servers, VpnConfig config)
{
if (_connectRequested)
{
_servers = servers;
_config = config;
}
else
{
_origin.UpdateServers(servers, config);
}
}
public OpenVpnProcessParams(
VpnEndpoint endpoint,
int managementPort,
string password,
VpnConfig config)
{
Endpoint = endpoint;
ManagementPort = managementPort;
Password = password;
CustomDns = config.CustomDns;
SkipIpv6 = config.SkipIpv6;
}
public void DeleteRoutes(VpnConfig vpnConfig)
{
switch (vpnConfig.SplitTunnelMode)
{
case SplitTunnelMode.Block:
foreach (string ip in vpnConfig.SplitTunnelIPs)
{
RoutingTableHelper.DeleteRoute(new NetworkAddress(ip).Ip);
}
break;
}
}
public void TestInitialize()
{
_logger = Substitute.For <ILogger>();
_taskQueue = new TaskQueue();
_origin = Substitute.For <ISingleVpnConnection>();
_endpoint = new VpnEndpoint(new VpnHost("proton.vpn", "135.27.46.203", string.Empty, null), VpnProtocol.OpenVpnTcp, 777);
_credentials = new VpnCredentials("username", "password", "cert",
new AsymmetricKeyPair(
new SecretKey("U2VjcmV0S2V5", KeyAlgorithm.Unknown),
new PublicKey("UHVibGljS2V5", KeyAlgorithm.Unknown)));
_config = new VpnConfig(new VpnConfigParameters());
}
public void Connect(VpnEndpoint endpoint, VpnCredentials credentials, VpnConfig config)
{
_endpoint = endpoint;
_credentials = credentials;
_config = config;
_connectRequested = true;
_disconnectRequested = false;
_disconnectError = VpnError.Unknown;
_logger.Info("HandlingRequestsWrapper: Connect requested, queuing Connect");
Queued(Connect);
}
public void Connect(VpnEndpoint endpoint, VpnCredentials credentials, VpnConfig config)
{
_vpnEndpoint = endpoint;
_vpnCredentials = credentials;
_config = config;
_cancellationHandle.Cancel();
var cancellationToken = _cancellationHandle.Token;
_disconnectDelay = Task.Delay(DisconnectDelay, cancellationToken);
Queued(ScanPorts, cancellationToken);
}
public void Connect(VpnEndpoint endpoint, VpnCredentials credentials, VpnConfig config)
{
if (endpoint.Server.X25519PublicKey == null)
{
InvokeStateChange(VpnStatus.Disconnected, VpnError.MissingServerPublicKey);
return;
}
_credentials = credentials;
_endpoint = endpoint;
_vpnConfig = config;
_connectAction.Run();
}
public void Connect(IReadOnlyList <VpnHost> servers, VpnConfig config, VpnProtocol protocol, VpnCredentials credentials)
{
_reconnectPending = false;
_reconnecting = false;
_disconnecting = false;
_protocol = protocol;
_credentials = credentials;
_config = config;
_candidates.Set(servers);
_candidates.Reset();
_endpoint = _candidates.Next(_protocol);
_origin.Connect(_endpoint, credentials, config);
}
public void UpdateServers(IReadOnlyList <VpnHost> servers, VpnConfig config)
{
_candidates.Set(servers);
_logger.Info("VPN endpoint candidates updated");
if (_reconnectPending ||
_state.Status == VpnStatus.Disconnected ||
_state.Status == VpnStatus.Disconnecting ||
_candidates.Contains(_candidates.Current))
{
return;
}
_logger.Info("Current VPN endpoint is not in VPN endpoint candidates, disconnecting");
_origin.Disconnect(VpnError.Unknown);
}
private static VpnConfigContract Map(VpnConfig config)
{
Dictionary <VpnProtocolContract, int[]> portConfig =
config.Ports.ToDictionary(p => Map(p.Key), p => p.Value.ToArray());
return(new VpnConfigContract
{
Ports = portConfig,
CustomDns = config.CustomDns.ToList(),
SplitTunnelMode = config.SplitTunnelMode,
SplitTunnelIPs = config.SplitTunnelIPs.ToList(),
NetShieldMode = config.NetShieldMode,
VpnProtocol = Map(config.VpnProtocol),
PreferredProtocols = Map(config.PreferredProtocols),
SplitTcp = config.SplitTcp,
});
}
public void SetUpRoutingTable(VpnConfig vpnConfig, string localIp)
{
INetworkInterface adapter = _networkInterfaceLoader.GetByVpnProtocol(vpnConfig.VpnProtocol, vpnConfig.OpenVpnAdapter);
switch (vpnConfig.SplitTunnelMode)
{
case SplitTunnelMode.Permit:
//Remove default wireguard route as it has metric 0, but instead we add the same route with low priority
//so that we still have the route for include mode apps to be routed through the tunnel.
RoutingTableHelper.DeleteRoute("0.0.0.0", "0.0.0.0", localIp);
RoutingTableHelper.CreateRoute("0.0.0.0", "0.0.0.0", localIp, adapter.Index, ROUTE_METRIC);
RoutingTableHelper.CreateRoute(_config.WireGuard.DefaultDnsServer, "255.255.255.255", localIp, adapter.Index, ROUTE_METRIC);
foreach (string ip in vpnConfig.SplitTunnelIPs)
{
NetworkAddress address = new(ip);
RoutingTableHelper.CreateRoute(address.Ip, address.Mask, localIp, adapter.Index, ROUTE_METRIC);
}
break;
case SplitTunnelMode.Block:
INetworkInterface bestInterface = _networkInterfaces.GetBestInterface(_config.GetHardwareId(vpnConfig.OpenVpnAdapter));
int result = RoutingTableHelper.GetIpInterfaceEntry(bestInterface.Index, out MibIPInterfaceRow interfaceRow);
if (result == 0)
{
foreach (string ip in vpnConfig.SplitTunnelIPs)
{
NetworkAddress address = new(ip);
RoutingTableHelper.CreateRoute(
address.Ip,
address.Mask,
bestInterface.DefaultGateway.ToString(),
bestInterface.Index,
(int)interfaceRow.Metric);
}
}
break;
}
}
public void Connect(VpnEndpoint endpoint, VpnCredentials credentials, VpnConfig config)
{
_origin.Connect(endpoint, credentials, config);
}
public IEnumerable <ValidationResult> Validate(ValidationContext validationContext)
{
return(Credentials.Validate(validationContext)
.Concat(VpnConfig.Validate(validationContext))
.Concat(GetServerValidationResult(validationContext)));
}
public void Connect(VpnEndpoint endpoint, VpnCredentials credentials, VpnConfig config)
{
_vpnProtocol = config.VpnProtocol;
VpnConnection.Connect(endpoint, credentials, config);
}
public void UpdateServers(IReadOnlyList <VpnHost> servers, VpnConfig config)
{
_origin.UpdateServers(servers, config);
}
public void Connect(IReadOnlyList <VpnHost> servers, VpnConfig config, VpnCredentials credentials)
{
_origin.Connect(servers, config, credentials);
}
public async Task UpdateServers(IReadOnlyList<VpnHost> servers, VpnConfig config)
{
await InvokeAction(() => _decorated.UpdateServers(servers, config));
}
