[Tor] Towards Whonix & Tails

WalletWasabi.Daemon/Config.cs

@@ -59,6 +59,9 @@
  [ nameof(UseTor)] = (
  "All the communications go through the Tor network",
  GetBoolValue("UseTor", PersistentConfig.UseTor, cliArgs)),
+ [ nameof(UseOnlyRunningTor)] = (
+ "Connect to an already running Tor instance without attempting to run the bundled Tor",
+ GetBoolValue("UseOnlyRunningTor", false, cliArgs)),
  [ nameof(TorFolder)] = (
  "Folder where Tor binary is located",
  GetNullableStringValue("TorFolder", null, cliArgs)),
@@ -155,6 +158,7 @@
  public string? TestNetCoordinatorUri => GetEffectiveValue<NullableStringValue, string?>(nameof(TestNetCoordinatorUri));
  public string? RegTestCoordinatorUri => GetEffectiveValue<NullableStringValue, string?>(nameof(RegTestCoordinatorUri));
  public bool UseTor => GetEffectiveValue<BoolValue, bool>(nameof(UseTor)) && Network != Network.RegTest;
+ public bool UseOnlyRunningTor => GetEffectiveValue<BoolValue, bool>(nameof(UseOnlyRunningTor));
  public string? TorFolder => GetEffectiveValue<NullableStringValue, string?>(nameof(TorFolder));
  public int TorSocksPort => GetEffectiveValue<IntValue, int>(nameof(TorSocksPort));
  public int TorControlPort => GetEffectiveValue<IntValue, int>(nameof(TorControlPort));

WalletWasabi.Daemon/Global.cs

@@ -1,4 +1,4 @@
 using Microsoft.Extensions.Caching.Memory;
 using NBitcoin;
 using Nito.AsyncEx;
 using System;
@@ -54,7 +54,8 @@
  TorSettings = new TorSettings(
  DataDir,
  distributionFolderPath: EnvironmentHelpers.GetFullBaseDirectory(),
- Config.TerminateTorOnExit,
+ terminateOnExit: Config.TerminateTorOnExit,
+ useOnlyRunningTor: Config.UseOnlyRunningTor,
  socksPort: config.TorSocksPort,
  controlPort: config.TorControlPort,
  torFolder: config.TorFolder,
@@ -186,7 +187,8 @@
  private WasabiHttpClientFactory BuildHttpClientFactory(Func<Uri> backendUriGetter) =>
  new(
  Config.UseTor ? TorSettings.SocksEndpoint : null,
- backendUriGetter);
+ backendUriGetter,
+ torControlAvailable: !TorSettings.UseOnlyRunningTor);
 
  public async Task InitializeNoWalletAsync(bool initializeSleepInhibitor, TerminateService terminateService, CancellationToken cancellationToken)
  {
@@ -333,7 +335,12 @@
  }
  }
 
- HostedServices.Register<TorMonitor>(() => new TorMonitor(period: TimeSpan.FromMinutes(1), torProcessManager: TorManager, httpClientFactory: HttpClientFactory), nameof(TorMonitor));
+ // Do not monitor Tor when Tor is an already running service.
+ if (!TorSettings.UseOnlyRunningTor)
+ {
+ HostedServices.Register<TorMonitor>(() => new TorMonitor(period: TimeSpan.FromMinutes(1), torProcessManager: TorManager, httpClientFactory: HttpClientFactory), nameof(TorMonitor));
+ }
+
  HostedServices.Register<TorStatusChecker>(() => TorStatusChecker, "Tor Network Checker");
  }
  }

WalletWasabi.Tests/UnitTests/Tor/Socks5/Pool/TorHttpPoolTests.cs

@@ -45,7 +45,7 @@ public async Task UseCorrectIdentitiesAsync()
  TorTcpConnectionFactory tcpConnectionFactory = mockTcpConnectionFactory.Object;
 
  // Use implementation of TorHttpPool and only replace SendCoreAsync behavior.
- Mock<TorHttpPool> mockTorHttpPool = new(MockBehavior.Loose, tcpConnectionFactory) { CallBase = true };
+ Mock<TorHttpPool> mockTorHttpPool = new(MockBehavior.Loose, tcpConnectionFactory, true) { CallBase = true };
  mockTorHttpPool.Setup(x => x.SendCoreAsync(It.IsAny<TorTcpConnection>(), It.IsAny<HttpRequestMessage>(), It.IsAny<Uri>(), It.IsAny<CancellationToken>()))
  .Returns((TorTcpConnection tcpConnection, HttpRequestMessage request, Uri requestUriOverride, CancellationToken cancellationToken) =>
  {
@@ -373,7 +373,7 @@ public async Task PersonCircuitLifetimeAsync()
  Mock<TorTcpConnectionFactory> mockTcpConnectionFactory = new(MockBehavior.Strict, new IPEndPoint(IPAddress.Loopback, 7777));
  mockTcpConnectionFactory.Setup(c => c.ConnectAsync(It.IsAny<Uri>(), aliceCircuit, It.IsAny<CancellationToken>())).ReturnsAsync(aliceConnection);
 
- Mock<TorHttpPool> mockTorHttpPool = new(MockBehavior.Loose, mockTcpConnectionFactory.Object) { CallBase = true };
+ Mock<TorHttpPool> mockTorHttpPool = new(MockBehavior.Loose, mockTcpConnectionFactory.Object, true) { CallBase = true };
  mockTorHttpPool.Setup(x => x.SendCoreAsync(It.IsAny<TorTcpConnection>(), It.IsAny<HttpRequestMessage>(), It.IsAny<Uri>(), It.IsAny<CancellationToken>()))
  .Returns((TorTcpConnection tcpConnection, HttpRequestMessage request, Uri requestUriOverride, CancellationToken cancellationToken) =>
  {

WalletWasabi/Tor/Socks5/Pool/TorHttpPool.cs

@@ -1,4 +1,4 @@
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.IO;
@@ -41,15 +41,16 @@
  SingleWriter = false,
  };
 
- public TorHttpPool(EndPoint endpoint)
- : this(new TorTcpConnectionFactory(endpoint))
+ public TorHttpPool(EndPoint endpoint, bool torControlAvailable = true)
+ : this(new TorTcpConnectionFactory(endpoint), torControlAvailable)
  {
  }
 
  /// <summary>Constructor that helps in tests.</summary>
- internal TorHttpPool(TorTcpConnectionFactory tcpConnectionFactory)
+ internal TorHttpPool(TorTcpConnectionFactory tcpConnectionFactory, bool torControlAvailable = true)
  {
  TcpConnectionFactory = tcpConnectionFactory;
+ TorControlAvailable = torControlAvailable;
  PreBuildingRequestChannel = Channel.CreateUnbounded<TorPrebuildCircuitRequest>(Options);
  PreBuildingLoopTask = Task.Run(PreBuildingLoopAsync);
  }
@@ -72,7 +73,7 @@
  private object ConnectionsLock { get; } = new();
 
  private TorTcpConnectionFactory TcpConnectionFactory { get; }
-
+ public bool TorControlAvailable { get; }
  public static DateTimeOffset? TorDoesntWorkSince { get; private set; }
 
  public Task<bool> IsTorRunningAsync(CancellationToken cancel)
@@ -407,47 +408,53 @@
 
  private async Task<TorTcpConnection?> CreateNewConnectionAsync(Uri requestUri, INamedCircuit circuit, CancellationToken cancellationToken)
  {
- lock (ConnectionsLock)
+ if (TorControlAvailable)
  {
- TorStreamsBeingBuilt[circuit.Name] = null;
+ lock (ConnectionsLock)
+ {
+ TorStreamsBeingBuilt[circuit.Name] = null;
+ }
  }
 
  TorTcpConnection? connection = null;
 
  try
  {
  connection = await TcpConnectionFactory.ConnectAsync(requestUri, circuit, cancellationToken).ConfigureAwait(false);
  Logger.LogTrace($"[NEW {connection}]['{requestUri}'] Created new Tor SOCKS5 connection.");
  }
  catch (TorConnectCommandFailedException e) when (e.RepField == RepField.TtlExpired)
  {
  Logger.LogTrace($"['{requestUri}'] TTL expired occurred. Probably some relay/networking problem. No need to worry too much.");
  throw;
  }
  catch (TorException e)
  {
  Logger.LogTrace($"['{requestUri}'][ERROR] Failed to create a new pool connection.", e);
  throw;
  }
  catch (OperationCanceledException)
  {
  Logger.LogTrace($"['{requestUri}'] Operation was canceled.");
  throw;
  }
  catch (Exception e)
  {
  Logger.LogTrace($"['{requestUri}'][EXCEPTION] {e}");
  throw;
  }
  finally
  {
  lock (ConnectionsLock)
  {
- if (TorStreamsBeingBuilt.Remove(circuit.Name, out TorStreamInfo? streamInfo))
+ if (TorControlAvailable)
  {
- if (connection is not null && streamInfo is not null)
+ if (TorStreamsBeingBuilt.Remove(circuit.Name, out TorStreamInfo? streamInfo))
  {
- connection.SetLatestStreamInfo(streamInfo, ifEmpty: true);
+ if (connection is not null && streamInfo is not null)
+ {
+ connection.SetLatestStreamInfo(streamInfo, ifEmpty: true);
+ }
  }
  }
 
@@ -524,6 +531,11 @@
  /// </remarks>
  public void ReportStreamStatus(string streamUsername, StreamStatusFlag streamStatus, string circuitID)
  {
+ if (!TorControlAvailable)
+ {
+ throw new UnreachableException("This method can be called only if Wasabi was run with Tor Control support.");
+ }
+
  lock (ConnectionsLock)
  {
  // If the key is not present, then are not the ones starting that Tor stream.

WalletWasabi/Tor/TorMonitor.cs

@@ -23,6 +23,7 @@
 namespace WalletWasabi.Tor;
 
 /// <summary>Monitors Tor process bootstrap and reachability of Wasabi Backend.</summary>
+/// <remarks>Tor Monitor can only work if Tor Control is available.</remarks>
 public class TorMonitor : PeriodicRunner
 {
  public static readonly TimeSpan CheckIfRunningAfterTorMisbehavedFor = TimeSpan.FromMinutes(10);
@@ -107,7 +108,7 @@ private async Task MonitorEventsAsync(CancellationToken cancellationToken)
  using CancellationTokenSource linkedCts2 = CancellationTokenSource.CreateLinkedTokenSource(linkedCts.Token, torTerminatedCancellationToken);
 
  Logger.LogInfo("Starting Tor bootstrap monitor…");
- await torControlClient.SubscribeEventsAsync(EventNames, linkedCts2.Token).ConfigureAwait(false);
+ await torControlClient!.SubscribeEventsAsync(EventNames, linkedCts2.Token).ConfigureAwait(false);
  bool circuitEstablished = false;
 
  await foreach (TorControlReply reply in torControlClient.ReadEventsAsync(linkedCts2.Token).ConfigureAwait(false))

WalletWasabi/Tor/TorProcessManager.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Diagnostics;
 using System.IO;
 using System.Linq;
@@ -21,7 +22,7 @@
  internal const string TorProcessStartedByDifferentUser = "Tor was started by another user and we can't use it nor kill it.";
 
  /// <summary>Task completion source returning a cancellation token which is canceled when Tor process is terminated.</summary>
- private volatile TaskCompletionSource<(CancellationToken, TorControlClient)> _tcs = new();
+ private volatile TaskCompletionSource<(CancellationToken, TorControlClient?)> _tcs = new();
 
  public TorProcessManager(TorSettings settings) :
  this(settings, new(settings.SocksEndpoint))
@@ -50,14 +51,20 @@
  private TorSettings Settings { get; }
  private TorTcpConnectionFactory TcpConnectionFactory { get; }
 
- /// <remarks>Guarded by <see cref="StateLock"/>.</remarks>
+ /// <remarks>
+ /// Only set if <see cref="TorSettings.UseOnlyRunningTor"/> is not on.
+ /// <para>Guarded by <see cref="StateLock"/>.</para>
+ /// </remarks>
  private ProcessAsync? TorProcess { get; set; }
 
- /// <remarks>Guarded by <see cref="StateLock"/>.</remarks>
+ /// <remarks>
+ /// Only set if <see cref="TorSettings.UseOnlyRunningTor"/> is not on.
+ /// <para>Guarded by <see cref="StateLock"/>.</para>
+ /// </remarks>
  private TorControlClient? TorControlClient { get; set; }
 
  /// <inheritdoc cref="StartAsync(int, CancellationToken)"/>
- public Task<(CancellationToken, TorControlClient)> StartAsync(CancellationToken cancellationToken)
+ public Task<(CancellationToken, TorControlClient?)> StartAsync(CancellationToken cancellationToken)
  {
  return StartAsync(attempts: 1, cancellationToken);
  }
@@ -68,7 +75,7 @@
  /// <remarks>This method must be called exactly once.</remarks>
  /// <exception cref="OperationCanceledException">When the operation is cancelled by the user.</exception>
  /// <exception cref="InvalidOperationException">When all attempts are tried without success.</exception>
- public async Task<(CancellationToken, TorControlClient)> StartAsync(int attempts, CancellationToken cancellationToken)
+ public async Task<(CancellationToken, TorControlClient?)> StartAsync(int attempts, CancellationToken cancellationToken)
  {
  LoopTask = RestartingLoopAsync(cancellationToken);
 
@@ -94,7 +101,7 @@
  /// <summary>Waits until Tor process is fully started or until it is stopped for some reason.</summary>
  /// <returns>Cancellation token which is canceled once Tor process terminates or once <paramref name="cancellationToken"/> is canceled.</returns>
  /// <remarks>This is useful to set up Tor control monitors that need to be restarted once Tor process is started again.</remarks>
- public Task<(CancellationToken, TorControlClient)> WaitForNextAttemptAsync(CancellationToken cancellationToken)
+ public Task<(CancellationToken, TorControlClient?)> WaitForNextAttemptAsync(CancellationToken cancellationToken)
  {
  return _tcs.Task.WaitAsync(cancellationToken);
  }
@@ -103,182 +110,219 @@
  /// <param name="globalCancellationToken">Application lifetime cancellation token.</param>
  private async Task RestartingLoopAsync(CancellationToken globalCancellationToken)
  {
- using var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(globalCancellationToken, LoopCts.Token);
+ if (Settings.UseOnlyRunningTor)
+ {
+ await RestartingLoopForRunningTorAsync(globalCancellationToken).ConfigureAwait(false);
+ }
+ else
+ {
+ await RestartingLoopForBundledTorAsync(globalCancellationToken).ConfigureAwait(false);
+ }
+ }
+
+ private async Task RestartingLoopForRunningTorAsync(CancellationToken globalCancellationToken)
+ {
+ using CancellationTokenSource linkedCts = CancellationTokenSource.CreateLinkedTokenSource(globalCancellationToken, LoopCts.Token);
+ CancellationToken cancellationToken = linkedCts.Token;
+
+ bool detectedTorState = false;
+ CancellationTokenSource torStoppedCts = new();
+
+ while (!cancellationToken.IsCancellationRequested)
+ {
+ bool isTorRunning = await TcpConnectionFactory.IsTorRunningAsync(cancellationToken).ConfigureAwait(false);
+
+ if (detectedTorState && isTorRunning) // Case: Still running.
+ {
+ // No-op.
+ }
+ else if (!detectedTorState && isTorRunning) // Case: Started running.
+ {
+ _tcs.SetResult((torStoppedCts.Token, null));
+ }
+ else if (detectedTorState && !isTorRunning) // Case: Stopped running.
+ {
+ bool willWaitForTorRestart = !cancellationToken.IsCancellationRequested;
+ OnTorStop(willWaitForTorRestart, exception: null, torStoppedCts, globalCancellationToken);
+ torStoppedCts = new();
+ }
+
+ detectedTorState = isTorRunning;
+
+ // We don't use Tor Control client with an already running Tor, so we just use a simple sleep mechanism.
+ await Task.Delay(TimeSpan.FromSeconds(10), cancellationToken).ConfigureAwait(ConfigureAwaitOptions.SuppressThrowing);
+
+ if (cancellationToken.IsCancellationRequested)
+ {
+ Logger.LogDebug("User canceled operation.");
+ break;
+ }
+ }
+
+ torStoppedCts.Dispose();
+ }
+
+ /// <summary>
+ /// Keeps starting Tor OS process.
+ /// </summary>
+ private async Task RestartingLoopForBundledTorAsync(CancellationToken globalCancellationToken)
+ {
+ using CancellationTokenSource linkedCts = CancellationTokenSource.CreateLinkedTokenSource(globalCancellationToken, LoopCts.Token);
  CancellationToken cancellationToken = linkedCts.Token;
 
  while (!cancellationToken.IsCancellationRequested)
  {
  ProcessAsync? process = null;
  TorControlClient? controlClient = null;
  Exception? exception = null;
  bool setNewTcs = true;
 
  // Use CancellationTokenSource to signal that Tor process terminated.
  using CancellationTokenSource cts = new();
 
  try
  {
  // Is Tor already running? Either our Tor process from previous Wasabi Wallet run or possibly user's own Tor.
  bool isAlreadyRunning = await TcpConnectionFactory.IsTorRunningAsync(cancellationToken).ConfigureAwait(false);
 
  if (isAlreadyRunning)
  {
  Logger.LogInfo($"Tor is already running on {Settings.SocksEndpoint}");
  controlClient = await InitTorControlAsync(cancellationToken).ConfigureAwait(false);
 
  // Tor process can crash even between these two commands too.
  int processId = await controlClient.GetTorProcessIdAsync(cancellationToken).ConfigureAwait(false);
  process = new ProcessAsync(Process.GetProcessById(processId));
 
  try
  {
  // Note: This is a workaround how to check whether we have sufficient permissions for the process.
  // Especially, we want to make sure that Tor is running under our user and not a different one.
  // Example situation: Tor is run under admin account but then the app is run under a non-privileged account.
  nint _ = process.Handle;
  }
  catch (Exception ex)
  {
  throw new NotSupportedException(TorProcessStartedByDifferentUser, ex);
  }
 
  TorControlReply clientTransportPluginReply = await controlClient.GetConfAsync(keyword: "ClientTransportPlugin", cancellationToken).ConfigureAwait(false);
  if (!clientTransportPluginReply.Success)
  {
  throw new InvalidOperationException("Tor control failed to report the current transport plugin.");
  }
 
  // Check if the bridges in the running Tor instance are the same as user requested.
  TorControlReply bridgeReply = await controlClient.GetConfAsync(keyword: "Bridge", cancellationToken).ConfigureAwait(false);
  if (!bridgeReply.Success)
  {
  throw new InvalidOperationException("Tor control failed to report active bridges.");
  }
 
  // Compare as two unordered sets.
  string[] currentBridges = bridgeReply.ResponseLines.Where(x => x != "Bridge").Select(x => x.Split('=', 2)[1]).Order().ToArray();
  bool areBridgesAsRequired = currentBridges.SequenceEqual(Settings.Bridges.Order());
- 
+
  if (!areBridgesAsRequired)
  {
  Logger.LogInfo("Tor bridges of the running Tor instance are different than required. Restarting Tor.");
  await controlClient.SignalShutdownAsync(cancellationToken).ConfigureAwait(false);
  continue;
  }
  }
  else
  {
  string arguments = Settings.GetCmdArguments();
  Logger.LogTrace($"Starting Tor with arguments: {arguments}");
 
  process = StartProcess(arguments);
 
  bool isRunning = await EnsureRunningAsync(process, cancellationToken).ConfigureAwait(false);
 
  if (!isRunning)
  {
  Logger.LogTrace("Failed to start Tor process. Trying again.");
  continue;
  }
 
  controlClient = await InitTorControlAsync(cancellationToken).ConfigureAwait(false);
  }
 
  Logger.LogInfo("Tor is running.");
 
  // Only now we know that Tor process is fully started.
  lock (StateLock)
  {
  TorProcess = process;
  TorControlClient = controlClient;
 
  _tcs.SetResult((cts.Token, controlClient));
  }
 
  await process.WaitForExitAsync(cancellationToken).ConfigureAwait(false);
 
  Logger.LogDebug("Tor process exited.");
  }
  catch (OperationCanceledException)
  {
  Logger.LogDebug("User canceled operation.");
  setNewTcs = false;
  break;
  }
  catch (TorControlException ex)
  {
  Logger.LogDebug("Tor control failed to initialize.", ex);
 
  // If Tor control fails to initialize, we want to try to start Tor again and initialize Tor control again.
  if (process is not null)
  {
  Logger.LogDebug("Attempt to kill the running Tor process.");
  process.Kill();
  }
  else
  {
  // If Tor was already started, we don't have Tor process ID (pid), so it's harder to kill it.
  Process[] torProcesses = GetTorProcesses();
 
  bool killAttempt = false;
 
  foreach (Process torProcess in torProcesses)
  {
  try
  {
  // This throws if we can't access MainModule of an elevated process from a non elevated one.
  if (torProcess.MainModule?.FileName == Settings.TorBinaryFilePath)
  {
  Logger.LogInfo("Kill running Tor process to restart it again.");
  killAttempt = true;
  torProcess.Kill();
  }
  }
  catch
  {
  }
  }
 
  // Tor was started by another user and we can't kill it.
  if (torProcesses.Length == 0 || !killAttempt)
  {
  Logger.LogDebug("Failed to find the Tor process in the list of processes.");
  setNewTcs = false;
  exception = new NotSupportedException(TorProcessStartedByDifferentUser, ex);
  throw exception;
  }
  }
  }
  catch (Exception ex)
  {
  Logger.LogError("Unexpected problem in starting Tor.", ex);
  setNewTcs = false;
  exception = ex;
  throw;
  }
  finally
  {
- TaskCompletionSource<(CancellationToken, TorControlClient)> originalTcs = _tcs;
-
- if (setNewTcs)
- {
- // (1) and (2) must be in this order. Otherwise, there is a race condition risk of getting invalid CT by clients.
- TaskCompletionSource<(CancellationToken, TorControlClient)> newTcs = new();
- originalTcs = Interlocked.Exchange(ref _tcs, newTcs); // (1)
- }
-
- cts.Cancel(); // (2)
-
- if (exception is not null)
- {
- originalTcs.TrySetException(exception);
- }
- else
- {
- originalTcs.TrySetCanceled(globalCancellationToken);
- }
-
- cts.Dispose();
+ OnTorStop(setNewTcs, exception, cts, globalCancellationToken);
 
  if (controlClient is not null)
  {
@@ -296,6 +340,31 @@
  }
  }
 
+ private void OnTorStop(bool willWaitForTorRestart, Exception? exception, CancellationTokenSource torStoppedCts, CancellationToken globalCancellationToken)
+ {
+ TaskCompletionSource<(CancellationToken, TorControlClient?)> originalTcs = _tcs;
+
+ if (willWaitForTorRestart)
+ {
+ // (1) and (2) must be in this order. Otherwise, there is a race condition risk of getting invalid CT by clients.
+ TaskCompletionSource<(CancellationToken, TorControlClient?)> newTcs = new();
+ originalTcs = Interlocked.Exchange(ref _tcs, newTcs); // (1)
+ }
+
+ torStoppedCts.Cancel(); // (2)
+
+ if (exception is not null)
+ {
+ originalTcs.TrySetException(exception);
+ }
+ else
+ {
+ originalTcs.TrySetCanceled(globalCancellationToken);
+ }
+
+ torStoppedCts.Dispose();
+ }
+
  internal virtual Process[] GetTorProcesses()
  {
  return Process.GetProcessesByName(TorSettings.TorBinaryFileName);

WalletWasabi/Tor/TorSettings.cs

@@ -27,47 +27,59 @@
  string dataDir,
  string distributionFolderPath,
  bool terminateOnExit,
+ bool useOnlyRunningTor = false,
  int socksPort = DefaultSocksPort,
  int controlPort = DefaultControlPort,
  string? torFolder = null,
  string[]? bridges = null,
  int? owningProcessId = null,
  bool log = true)
  {
  IsCustomTorFolder = torFolder is not null;
 
  bool defaultWasabiTorPorts = socksPort == DefaultSocksPort && controlPort == DefaultControlPort;
 
  // Use different ports when user overrides Tor folder to avoid accessing the same control_auth_cookie file.
  if (IsCustomTorFolder && defaultWasabiTorPorts)
  {
  socksPort = 37152;
  controlPort = 37153;
  }
 
  TorBinaryDir = torFolder ?? Path.Combine(MicroserviceHelpers.GetBinaryFolder(), "Tor");
  TorBinaryFilePath = GetTorBinaryFilePath(TorBinaryDir);
  TorTransportPluginsDir = Path.Combine(TorBinaryDir, "PluggableTransports");
 
  TorDataDir = Path.Combine(dataDir, "tordata2");
  SocksEndpoint = new IPEndPoint(IPAddress.Loopback, socksPort);
  ControlEndpoint = new IPEndPoint(IPAddress.Loopback, controlPort);
  Bridges = bridges ?? [];
  OwningProcessId = owningProcessId;
 
  CookieAuthFilePath = defaultWasabiTorPorts
  ? Path.Combine(dataDir, $"control_auth_cookie")
  : Path.Combine(dataDir, $"control_auth_cookie_{socksPort}_{controlPort}");
 
  LogFilePath = Path.Combine(dataDir, "TorLogs.txt");
  IoHelpers.EnsureContainingDirectoryExists(LogFilePath);
  DistributionFolder = distributionFolderPath;
- TerminateOnExit = terminateOnExit;
+
+ if (useOnlyRunningTor && terminateOnExit)
+ {
+ Logger.LogWarning("Wasabi is instructed to use a running Tor process. Terminate on exit was disabled.");
+ }
+
+ UseOnlyRunningTor = useOnlyRunningTor; 
+ TerminateOnExit = useOnlyRunningTor ? false : terminateOnExit;
+
  Log = log;
  GeoIpPath = Path.Combine(DistributionFolder, "Tor", "Geoip", "geoip");
  GeoIp6Path = Path.Combine(DistributionFolder, "Tor", "Geoip", "geoip6");
  }
 
+ /// <summary><c>true</c> if Wasabi should not attempt to run any Tor process (bundled) or specified via <c>--TorFolder</c> command line option.</summary>
+ public bool UseOnlyRunningTor { get; }
+
  /// <summary><c>true</c> if user specified a custom Tor folder to run a (possibly) different Tor binary than the bundled Tor, <c>false</c> otherwise.</summary>
  public bool IsCustomTorFolder { get; }